@graphql-mesh/odata
Version:
916 lines (912 loc) • 76.3 kB
JavaScript
'use strict';
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
const utils = require('@graphql-mesh/utils');
const stringInterpolation = require('@graphql-mesh/string-interpolation');
const urljoin = _interopDefault(require('url-join'));
const graphqlCompose = require('graphql-compose');
const graphqlScalars = require('graphql-scalars');
const graphql = require('graphql');
const graphqlParseResolveInfo = require('graphql-parse-resolve-info');
const DataLoader = _interopDefault(require('dataloader'));
const httpStringParser = require('http-string-parser');
const pascalCase = require('pascal-case');
const EventEmitter = _interopDefault(require('events'));
const fastXmlParser = require('fast-xml-parser');
const utils$1 = require('@graphql-tools/utils');
const fetch = require('@whatwg-node/fetch');
const store = require('@graphql-mesh/store');
const delegate = require('@graphql-tools/delegate');
const crossHelpers = require('@graphql-mesh/cross-helpers');
const SCALARS = new Map([
['Edm.Binary', 'String'],
['Edm.Stream', 'String'],
['Edm.String', 'String'],
['Edm.Int16', 'Int'],
['Edm.Byte', 'Byte'],
['Edm.Int32', 'Int'],
['Edm.Int64', 'BigInt'],
['Edm.Double', 'Float'],
['Edm.Boolean', 'Boolean'],
['Edm.Guid', 'GUID'],
['Edm.DateTimeOffset', 'DateTime'],
['Edm.Date', 'Date'],
['Edm.TimeOfDay', 'String'],
['Edm.Single', 'Float'],
['Edm.Duration', 'ISO8601Duration'],
['Edm.Decimal', 'Float'],
['Edm.SByte', 'Byte'],
['Edm.GeographyPoint', 'String'],
]);
const queryOptionsFields = {
orderby: {
type: 'String',
description: 'A data service URI with a $orderby System Query Option specifies an expression for determining what values are used to order the collection of Entries identified by the Resource Path section of the URI. This query option is only supported when the resource path identifies a Collection of Entries.',
},
top: {
type: 'Int',
description: 'A data service URI with a $top System Query Option identifies a subset of the Entries in the Collection of Entries identified by the Resource Path section of the URI. This subset is formed by selecting only the first N items of the set, where N is an integer greater than or equal to zero specified by this query option. If a value less than zero is specified, the URI should be considered malformed.',
},
skip: {
type: 'Int',
description: 'A data service URI with a $skip System Query Option identifies a subset of the Entries in the Collection of Entries identified by the Resource Path section of the URI. That subset is defined by seeking N Entries into the Collection and selecting only the remaining Entries (starting with Entry N+1). N is an integer greater than or equal to zero specified by this query option. If a value less than zero is specified, the URI should be considered malformed.',
},
filter: {
type: 'String',
description: 'A URI with a $filter System Query Option identifies a subset of the Entries from the Collection of Entries identified by the Resource Path section of the URI. The subset is determined by selecting only the Entries that satisfy the predicate expression specified by the query option.',
},
inlinecount: {
type: 'InlineCount',
description: 'A URI with a $inlinecount System Query Option specifies that the response to the request includes a count of the number of Entries in the Collection of Entries identified by the Resource Path section of the URI. The count must be calculated after applying any $filter System Query Options present in the URI. The set of valid values for the $inlinecount query option are shown in the table below. If a value other than one shown in Table 4 is specified the URI is considered malformed.',
},
count: {
type: 'Boolean',
},
};
class ODataHandler {
constructor({ name, config, baseDir, importFn, logger, store: store$1 }) {
this.eventEmitterSet = new Set();
this.xmlParser = new fastXmlParser.XMLParser({
attributeNamePrefix: '',
attributesGroupName: 'attributes',
textNodeName: 'innerText',
ignoreAttributes: false,
removeNSPrefix: true,
isArray: (_, __, ___, isAttribute) => !isAttribute,
allowBooleanAttributes: true,
preserveOrder: false,
});
this.name = name;
this.config = config;
this.baseDir = baseDir;
this.importFn = importFn;
this.logger = logger;
this.metadataJson = store$1.proxy('metadata.json', store.PredefinedProxyOptions.JsonWithoutValidation);
}
async getCachedMetadataJson() {
return this.metadataJson.getWithSet(async () => {
const baseUrl = stringInterpolation.stringInterpolator.parse(this.config.baseUrl, {
env: crossHelpers.process.env,
});
const metadataUrl = urljoin(baseUrl, '$metadata');
const metadataText = await utils.readFileOrUrl(this.config.metadata || metadataUrl, {
allowUnknownExtensions: true,
cwd: this.baseDir,
headers: this.config.schemaHeaders,
fetch: this.fetchFn,
logger: this.logger,
importFn: this.importFn,
});
return this.xmlParser.parse(metadataText);
});
}
async getMeshSource({ fetchFn }) {
this.fetchFn = fetchFn;
const { baseUrl: nonInterpolatedBaseUrl, operationHeaders } = this.config;
const baseUrl = stringInterpolation.stringInterpolator.parse(nonInterpolatedBaseUrl, {
env: crossHelpers.process.env,
});
const schemaComposer = new graphqlCompose.SchemaComposer();
schemaComposer.add(graphqlScalars.GraphQLBigInt);
schemaComposer.add(graphqlScalars.GraphQLGUID);
schemaComposer.add(graphqlScalars.GraphQLDateTime);
schemaComposer.add(graphqlScalars.GraphQLJSON);
schemaComposer.add(graphqlScalars.GraphQLByte);
schemaComposer.add(graphqlScalars.GraphQLDate);
schemaComposer.add(graphqlScalars.GraphQLISO8601Duration);
const aliasNamespaceMap = new Map();
const metadataJson = await this.getCachedMetadataJson();
const schemas = metadataJson.Edmx[0].DataServices[0].Schema;
const multipleSchemas = schemas.length > 1;
const namespaces = new Set();
const contextDataloaderName = Symbol(`${this.name}DataLoader`);
function getNamespaceFromTypeRef(typeRef) {
let namespace = '';
namespaces === null || namespaces === void 0 ? void 0 : namespaces.forEach(el => {
if (typeRef.startsWith(el) &&
el.length > namespace.length && // It can be deeper namespace
!typeRef.replace(el + '.', '').includes('.') // Typename cannot have `.`
) {
namespace = el;
}
});
return namespace;
}
function getTypeNameFromRef({ typeRef, isInput, isRequired, }) {
const typeRefArr = typeRef.split('Collection(');
const arrayDepth = typeRefArr.length;
let actualTypeRef = typeRefArr.join('').split(')').join('');
const typeNamespace = getNamespaceFromTypeRef(actualTypeRef);
if (aliasNamespaceMap.has(typeNamespace)) {
const alias = aliasNamespaceMap.get(typeNamespace);
actualTypeRef = actualTypeRef.replace(typeNamespace, alias);
}
const actualTypeRefArr = actualTypeRef.split('.');
const typeName = multipleSchemas
? pascalCase.pascalCase(actualTypeRefArr.join('_'))
: actualTypeRefArr[actualTypeRefArr.length - 1];
let realTypeName = typeName;
if (SCALARS.has(actualTypeRef)) {
realTypeName = SCALARS.get(actualTypeRef);
}
else if (schemaComposer.isEnumType(typeName)) {
realTypeName = typeName;
}
else if (isInput) {
realTypeName += 'Input';
}
const fakeEmptyArr = new Array(arrayDepth);
realTypeName = fakeEmptyArr.join('[') + realTypeName + fakeEmptyArr.join(']');
if (isRequired) {
realTypeName += '!';
}
return realTypeName;
}
function getUrlString(url) {
return decodeURIComponent(url.toString()).split('+').join(' ');
}
function handleResponseText(responseText, urlString, info) {
let responseJson;
try {
responseJson = JSON.parse(responseText);
}
catch (error) {
const actualError = new Error(responseText);
Object.assign(actualError, {
extensions: {
url: urlString,
},
});
throw actualError;
}
if (responseJson.error) {
const actualError = new Error(responseJson.error.message || responseJson.error);
actualError.extensions = responseJson.error;
throw actualError;
}
const urlStringWithoutSearchParams = urlString.split('?')[0];
if (graphql.isListType(info.returnType)) {
const actualReturnType = graphql.getNamedType(info.returnType);
const entityTypeExtensions = actualReturnType.extensions;
if ('Message' in responseJson && !('value' in responseJson)) {
const error = new Error(responseJson.Message);
Object.assign(error, { extensions: responseJson });
throw error;
}
const returnList = responseJson.value;
return returnList.map(element => {
if (!(entityTypeExtensions === null || entityTypeExtensions === void 0 ? void 0 : entityTypeExtensions.entityInfo)) {
return element;
}
const urlOfElement = new URL(urlStringWithoutSearchParams);
addIdentifierToUrl(urlOfElement, entityTypeExtensions.entityInfo.identifierFieldName, entityTypeExtensions.entityInfo.identifierFieldTypeRef, element);
const identifierUrl = element['@odata.id'] || getUrlString(urlOfElement);
const fieldMap = actualReturnType.getFields();
for (const fieldName in element) {
if (entityTypeExtensions.entityInfo.navigationFields.includes(fieldName)) {
const field = element[fieldName];
let fieldType = fieldMap[fieldName].type;
if ('ofType' in fieldType) {
fieldType = fieldType.ofType;
}
const { entityInfo: fieldEntityInfo } = fieldType.extensions;
if (field instanceof Array) {
for (const fieldElement of field) {
const urlOfField = new URL(urljoin(identifierUrl, fieldName));
addIdentifierToUrl(urlOfField, fieldEntityInfo.identifierFieldName, fieldEntityInfo.identifierFieldTypeRef, fieldElement);
fieldElement['@odata.id'] = fieldElement['@odata.id'] || getUrlString(urlOfField);
}
}
else {
const urlOfField = new URL(urljoin(identifierUrl, fieldName));
addIdentifierToUrl(urlOfField, fieldEntityInfo.identifierFieldName, fieldEntityInfo.identifierFieldTypeRef, field);
field['@odata.id'] = field['@odata.id'] || getUrlString(urlOfField);
}
}
}
return {
'@odata.id': identifierUrl,
...element,
};
});
}
else {
const actualReturnType = info.returnType;
const entityTypeExtensions = actualReturnType.extensions;
if (!(entityTypeExtensions === null || entityTypeExtensions === void 0 ? void 0 : entityTypeExtensions.entityInfo)) {
return responseJson;
}
const identifierUrl = responseJson['@odata.id'] || urlStringWithoutSearchParams;
const fieldMap = actualReturnType.getFields();
for (const fieldName in responseJson) {
if (entityTypeExtensions === null || entityTypeExtensions === void 0 ? void 0 : entityTypeExtensions.entityInfo.navigationFields.includes(fieldName)) {
const field = responseJson[fieldName];
let fieldType = fieldMap[fieldName].type;
if ('ofType' in fieldType) {
fieldType = fieldType.ofType;
}
const { entityInfo: fieldEntityInfo } = fieldType.extensions;
if (field instanceof Array) {
for (const fieldElement of field) {
const urlOfField = new URL(urljoin(identifierUrl, fieldName));
addIdentifierToUrl(urlOfField, fieldEntityInfo.identifierFieldName, fieldEntityInfo.identifierFieldTypeRef, fieldElement);
fieldElement['@odata.id'] = fieldElement['@odata.id'] || getUrlString(urlOfField);
}
}
else {
const urlOfField = new URL(urljoin(identifierUrl, fieldName));
addIdentifierToUrl(urlOfField, fieldEntityInfo.identifierFieldName, fieldEntityInfo.identifierFieldTypeRef, field);
field['@odata.id'] = field['@odata.id'] || getUrlString(urlOfField);
}
}
}
return {
'@odata.id': responseJson['@odata.id'] || urlStringWithoutSearchParams,
...responseJson,
};
}
}
schemaComposer.createEnumTC({
name: 'InlineCount',
values: {
allpages: {
value: 'allpages',
description: 'The OData MUST include a count of the number of entities in the collection identified by the URI (after applying any $filter System Query Options present on the URI)',
},
none: {
value: 'none',
description: 'The OData service MUST NOT include a count in the response. This is equivalence to a URI that does not include a $inlinecount query string parameter.',
},
},
});
schemaComposer.createInputTC({
name: 'QueryOptions',
fields: queryOptionsFields,
});
const origHeadersFactory = stringInterpolation.getInterpolatedHeadersFactory(operationHeaders);
const headersFactory = (resolverData, method) => {
const headers = origHeadersFactory(resolverData);
if (headers.accept == null) {
headers.accept = 'application/json';
}
if (headers['content-type'] == null && method !== 'GET') {
headers['content-type'] = 'application/json';
}
return headers;
};
const { args: commonArgs, contextVariables } = stringInterpolation.parseInterpolationStrings([
...Object.values(operationHeaders || {}),
baseUrl,
]);
function getTCByTypeNames(...typeNames) {
for (const typeName of typeNames) {
try {
return schemaComposer.getAnyTC(typeName);
}
catch (_a) { }
}
return null;
}
function addIdentifierToUrl(url, identifierFieldName, identifierFieldTypeRef, args) {
url.href += `/${args[identifierFieldName]}/`;
}
function rebuildOpenInputObjects(input) {
if (typeof input === 'object') {
if ('rest' in input) {
Object.assign(input, input.rest);
delete input.rest;
}
for (const fieldName in input) {
rebuildOpenInputObjects(input[fieldName]);
}
}
}
function handleBatchJsonResults(batchResponseJson, requests) {
if ('error' in batchResponseJson) {
const error = new Error(batchResponseJson.error.message);
Object.assign(error, {
extensions: batchResponseJson.error,
});
throw error;
}
if (!('responses' in batchResponseJson)) {
const error = new Error(batchResponseJson.ExceptionMessage ||
batchResponseJson.Message ||
`Batch Request didn't return a valid response.`);
Object.assign(error, {
extensions: batchResponseJson,
});
throw error;
}
return requests.map((_req, index) => {
const responseObj = batchResponseJson.responses.find((res) => res.id === index.toString());
return new fetch.Response(JSON.stringify(responseObj.body), {
status: responseObj.status,
headers: responseObj.headers,
});
});
}
const DATALOADER_FACTORIES = {
multipart: (context) => new DataLoader(async (requests) => {
var _a;
let requestBody = '';
const requestBoundary = 'batch_' + Date.now();
for (const requestIndex in requests) {
requestBody += `--${requestBoundary}\n`;
const request = requests[requestIndex];
requestBody += `Content-Type: application/http\n`;
requestBody += `Content-Transfer-Encoding:binary\n`;
requestBody += `Content-ID: ${requestIndex}\n\n`;
requestBody += `${request.method} ${request.url} HTTP/1.1\n`;
(_a = request.headers) === null || _a === void 0 ? void 0 : _a.forEach((value, key) => {
requestBody += `${key}: ${value}\n`;
});
if (request.body) {
const bodyAsStr = await request.text();
requestBody += `Content-Length: ${bodyAsStr.length}`;
requestBody += `\n`;
requestBody += bodyAsStr;
}
requestBody += `\n`;
}
requestBody += `--${requestBoundary}--\n`;
const batchHeaders = headersFactory({
context,
env: crossHelpers.process.env,
}, 'POST');
batchHeaders['content-type'] = `multipart/mixed;boundary=${requestBoundary}`;
const batchResponse = await this.fetchFn(urljoin(baseUrl, '$batch'), {
method: 'POST',
body: requestBody,
headers: batchHeaders,
});
if (batchResponse.headers.get('content-type').includes('json')) {
const batchResponseJson = await batchResponse.json();
return handleBatchJsonResults(batchResponseJson, requests);
}
const batchResponseText = await batchResponse.text();
const responseLines = batchResponseText.split('\n');
const responseBoundary = responseLines[0];
const actualResponse = responseLines.slice(1, responseLines.length - 2).join('\n');
const responseTextArr = actualResponse.split(responseBoundary);
return responseTextArr.map(responseTextWithContentHeader => {
const responseText = responseTextWithContentHeader.split('\n').slice(4).join('\n');
const { body, headers, statusCode, statusMessage } = httpStringParser.parseResponse(responseText);
return new fetch.Response(body, {
headers,
status: parseInt(statusCode),
statusText: statusMessage,
});
});
}),
json: (context) => new DataLoader(async (requests) => {
const batchHeaders = headersFactory({
context,
env: crossHelpers.process.env,
}, 'POST');
batchHeaders['content-type'] = 'application/json';
const batchResponse = await this.fetchFn(urljoin(baseUrl, '$batch'), {
method: 'POST',
body: JSON.stringify({
requests: await Promise.all(requests.map(async (request, index) => {
var _a;
const id = index.toString();
const url = request.url.replace(baseUrl, '');
const method = request.method;
const headers = {};
(_a = request.headers) === null || _a === void 0 ? void 0 : _a.forEach((value, key) => {
headers[key] = value;
});
return {
id,
url,
method,
body: request.body && (await request.json()),
headers,
};
})),
}),
headers: batchHeaders,
});
const batchResponseJson = await batchResponse.json();
return handleBatchJsonResults(batchResponseJson, requests);
}),
none: () =>
// We should refactor here
new DataLoader((requests) => Promise.all(requests.map(async (request) => this.fetchFn(request.url, {
method: request.method,
body: request.body && (await request.text()),
headers: request.headers,
})))),
};
const dataLoaderFactory = utils$1.memoize1(DATALOADER_FACTORIES[this.config.batch || 'none']);
function buildName({ schemaNamespace, name }) {
const alias = aliasNamespaceMap.get(schemaNamespace) || schemaNamespace;
const ref = alias + '.' + name;
return multipleSchemas ? pascalCase.pascalCase(ref.split('.').join('_')) : name;
}
schemas === null || schemas === void 0 ? void 0 : schemas.forEach((schemaObj) => {
const schemaNamespace = schemaObj.attributes.Namespace;
namespaces.add(schemaNamespace);
const schemaAlias = schemaObj.attributes.Alias;
if (schemaAlias) {
aliasNamespaceMap.set(schemaNamespace, schemaAlias);
}
});
schemas === null || schemas === void 0 ? void 0 : schemas.forEach((schemaObj) => {
var _a, _b, _c;
const schemaNamespace = schemaObj.attributes.Namespace;
(_a = schemaObj.EnumType) === null || _a === void 0 ? void 0 : _a.forEach((enumObj) => {
var _a;
const values = {};
(_a = enumObj.Member) === null || _a === void 0 ? void 0 : _a.forEach((memberObj) => {
const key = memberObj.attributes.Name;
// This doesn't work.
// const value = memberElement.getAttribute('Value')!;
values[key] = {
value: key,
extensions: { memberObj },
};
});
const enumTypeName = buildName({ schemaNamespace, name: enumObj.attributes.Name });
schemaComposer.createEnumTC({
name: enumTypeName,
values,
extensions: { enumObj },
});
});
const allTypes = (schemaObj.EntityType || []).concat(schemaObj.ComplexType || []);
const typesWithBaseType = allTypes.filter((typeObj) => typeObj.attributes.BaseType);
allTypes === null || allTypes === void 0 ? void 0 : allTypes.forEach((typeObj) => {
var _a, _b, _c;
const entityTypeName = buildName({ schemaNamespace, name: typeObj.attributes.Name });
const isOpenType = typeObj.attributes.OpenType === 'true';
const isAbstract = typeObj.attributes.Abstract === 'true';
const eventEmitter = new EventEmitter();
eventEmitter.setMaxListeners(Infinity);
this.eventEmitterSet.add(eventEmitter);
const extensions = {
entityInfo: {
actualFields: [],
navigationFields: [],
isOpenType,
},
typeObj,
eventEmitter,
};
const inputType = schemaComposer.createInputTC({
name: entityTypeName + 'Input',
fields: {},
extensions: () => extensions,
});
let abstractType;
if (typesWithBaseType.some((typeObj) => typeObj.attributes.BaseType.includes(`.${entityTypeName}`)) ||
isAbstract) {
abstractType = schemaComposer.createInterfaceTC({
name: isAbstract ? entityTypeName : `I${entityTypeName}`,
extensions,
resolveType: (root) => {
var _a;
const typeRef = (_a = root['@odata.type']) === null || _a === void 0 ? void 0 : _a.replace('#', '');
if (typeRef) {
const typeName = getTypeNameFromRef({
typeRef: root['@odata.type'].replace('#', ''),
isInput: false,
isRequired: false,
});
return typeName;
}
return isAbstract ? `T${entityTypeName}` : entityTypeName;
},
});
}
const outputType = schemaComposer.createObjectTC({
name: isAbstract ? `T${entityTypeName}` : entityTypeName,
extensions,
interfaces: abstractType ? [abstractType] : [],
});
abstractType === null || abstractType === void 0 ? void 0 : abstractType.setInputTypeComposer(inputType);
outputType.setInputTypeComposer(inputType);
const propertyRefObj = typeObj.Key && typeObj.Key[0].PropertyRef[0];
if (propertyRefObj) {
extensions.entityInfo.identifierFieldName = propertyRefObj.attributes.Name;
}
(_a = typeObj.Property) === null || _a === void 0 ? void 0 : _a.forEach((propertyObj) => {
const propertyName = propertyObj.attributes.Name;
extensions.entityInfo.actualFields.push(propertyName);
const propertyTypeRef = propertyObj.attributes.Type;
if (propertyName === extensions.entityInfo.identifierFieldName) {
extensions.entityInfo.identifierFieldTypeRef = propertyTypeRef;
}
const isRequired = propertyObj.attributes.Nullable === 'false';
inputType.addFields({
[propertyName]: {
type: getTypeNameFromRef({
typeRef: propertyTypeRef,
isInput: true,
isRequired,
}),
extensions: { propertyObj },
},
});
const field = {
type: getTypeNameFromRef({
typeRef: propertyTypeRef,
isInput: false,
isRequired,
}),
extensions: { propertyObj },
};
abstractType === null || abstractType === void 0 ? void 0 : abstractType.addFields({
[propertyName]: field,
});
outputType.addFields({
[propertyName]: field,
});
});
(_b = typeObj.NavigationProperty) === null || _b === void 0 ? void 0 : _b.forEach((navigationPropertyObj) => {
const navigationPropertyName = navigationPropertyObj.attributes.Name;
extensions.entityInfo.navigationFields.push(navigationPropertyName);
const navigationPropertyTypeRef = navigationPropertyObj.attributes.Type;
const isRequired = navigationPropertyObj.attributes.Nullable === 'false';
const isList = navigationPropertyTypeRef.startsWith('Collection(');
if (isList) {
const singularField = {
type: getTypeNameFromRef({
typeRef: navigationPropertyTypeRef,
isInput: false,
isRequired,
})
.replace('[', '')
.replace(']', ''),
args: {
...commonArgs,
id: {
type: 'ID',
},
},
extensions: { navigationPropertyObj },
resolve: async (root, args, context, info) => {
if (navigationPropertyName in root) {
return root[navigationPropertyName];
}
const url = new URL(root['@odata.id']);
url.href = urljoin(url.href, '/' + navigationPropertyName);
const returnType = info.returnType;
const { entityInfo } = returnType.extensions;
addIdentifierToUrl(url, entityInfo.identifierFieldName, entityInfo.identifierFieldTypeRef, args);
const parsedInfoFragment = graphqlParseResolveInfo.parseResolveInfo(info);
const searchParams = this.prepareSearchParams(parsedInfoFragment, info.schema);
searchParams === null || searchParams === void 0 ? void 0 : searchParams.forEach((value, key) => {
url.searchParams.set(key, value);
});
const urlString = getUrlString(url);
const method = 'GET';
const request = new fetch.Request(urlString, {
method,
headers: headersFactory({
root,
args,
context,
info,
env: crossHelpers.process.env,
}, method),
});
const response = await context[contextDataloaderName].load(request);
const responseText = await response.text();
return handleResponseText(responseText, urlString, info);
},
};
const pluralField = {
type: getTypeNameFromRef({
typeRef: navigationPropertyTypeRef,
isInput: false,
isRequired,
}),
args: {
...commonArgs,
queryOptions: { type: 'QueryOptions' },
},
extensions: { navigationPropertyObj },
resolve: async (root, args, context, info) => {
if (navigationPropertyName in root) {
return root[navigationPropertyName];
}
const url = new URL(root['@odata.id']);
url.href = urljoin(url.href, '/' + navigationPropertyName);
const parsedInfoFragment = graphqlParseResolveInfo.parseResolveInfo(info);
const searchParams = this.prepareSearchParams(parsedInfoFragment, info.schema);
searchParams === null || searchParams === void 0 ? void 0 : searchParams.forEach((value, key) => {
url.searchParams.set(key, value);
});
const urlString = getUrlString(url);
const method = 'GET';
const request = new fetch.Request(urlString, {
method,
headers: headersFactory({
root,
args,
context,
info,
env: crossHelpers.process.env,
}, method),
});
const response = await context[contextDataloaderName].load(request);
const responseText = await response.text();
return handleResponseText(responseText, urlString, info);
},
};
abstractType === null || abstractType === void 0 ? void 0 : abstractType.addFields({
[navigationPropertyName]: pluralField,
[`${navigationPropertyName}ById`]: singularField,
});
outputType.addFields({
[navigationPropertyName]: pluralField,
[`${navigationPropertyName}ById`]: singularField,
});
}
else {
const field = {
type: getTypeNameFromRef({
typeRef: navigationPropertyTypeRef,
isInput: false,
isRequired,
}),
args: {
...commonArgs,
},
extensions: { navigationPropertyObj },
resolve: async (root, args, context, info) => {
if (navigationPropertyName in root) {
return root[navigationPropertyName];
}
const url = new URL(root['@odata.id']);
url.href = urljoin(url.href, '/' + navigationPropertyName);
const parsedInfoFragment = graphqlParseResolveInfo.parseResolveInfo(info);
const searchParams = this.prepareSearchParams(parsedInfoFragment, info.schema);
searchParams === null || searchParams === void 0 ? void 0 : searchParams.forEach((value, key) => {
url.searchParams.set(key, value);
});
const urlString = getUrlString(url);
const method = 'GET';
const request = new fetch.Request(urlString, {
method,
headers: headersFactory({
root,
args,
context,
info,
env: crossHelpers.process.env,
}, method),
});
const response = await context[contextDataloaderName].load(request);
const responseText = await response.text();
return handleResponseText(responseText, urlString, info);
},
};
abstractType === null || abstractType === void 0 ? void 0 : abstractType.addFields({
[navigationPropertyName]: field,
});
outputType.addFields({
[navigationPropertyName]: field,
});
}
});
if (isOpenType || outputType.getFieldNames().length === 0) {
extensions.entityInfo.isOpenType = true;
inputType.addFields({
rest: {
type: 'JSON',
},
});
abstractType === null || abstractType === void 0 ? void 0 : abstractType.addFields({
rest: {
type: 'JSON',
resolve: (root) => root,
},
});
outputType.addFields({
rest: {
type: 'JSON',
resolve: (root) => root,
},
});
}
const updateInputType = inputType.clone(`${entityTypeName}UpdateInput`);
(_c = updateInputType.getFieldNames()) === null || _c === void 0 ? void 0 : _c.forEach(fieldName => updateInputType.makeOptional(fieldName));
// Types might be considered as unused implementations of interfaces so we must prevent that
schemaComposer.addSchemaMustHaveType(outputType);
});
const handleUnboundFunctionObj = (unboundFunctionObj) => {
var _a;
const functionName = unboundFunctionObj.attributes.Name;
const returnTypeRef = unboundFunctionObj.ReturnType[0].attributes.Type;
const returnType = getTypeNameFromRef({
typeRef: returnTypeRef,
isInput: false,
isRequired: false,
});
schemaComposer.Query.addFields({
[functionName]: {
type: returnType,
args: {
...commonArgs,
},
resolve: async (root, args, context, info) => {
const url = new URL(baseUrl);
url.href = urljoin(url.href, '/' + functionName);
url.href += `(${Object.entries(args)
.filter(argEntry => argEntry[0] !== 'queryOptions')
.map(argEntry => argEntry.join(' = '))
.join(', ')})`;
const parsedInfoFragment = graphqlParseResolveInfo.parseResolveInfo(info);
const searchParams = this.prepareSearchParams(parsedInfoFragment, info.schema);
searchParams === null || searchParams === void 0 ? void 0 : searchParams.forEach((value, key) => {
url.searchParams.set(key, value);
});
const urlString = getUrlString(url);
const method = 'GET';
const request = new fetch.Request(urlString, {
method,
headers: headersFactory({
root,
args,
context,
info,
env: crossHelpers.process.env,
}, method),
});
const response = await context[contextDataloaderName].load(request);
const responseText = await response.text();
return handleResponseText(responseText, urlString, info);
},
},
});
(_a = unboundFunctionObj.Parameter) === null || _a === void 0 ? void 0 : _a.forEach((parameterObj) => {
const parameterName = parameterObj.attributes.Name;
const parameterTypeRef = parameterObj.attributes.Type;
const isRequired = parameterObj.attributes.Nullable === 'false';
const parameterType = getTypeNameFromRef({
typeRef: parameterTypeRef,
isInput: true,
isRequired,
});
schemaComposer.Query.addFieldArgs(functionName, {
[parameterName]: {
type: parameterType,
},
});
});
};
const handleBoundFunctionObj = (boundFunctionObj) => {
var _a, _b;
const functionName = boundFunctionObj.attributes.Name;
const functionRef = schemaNamespace + '.' + functionName;
const returnTypeRef = boundFunctionObj.ReturnType[0].attributes.Type;
const returnType = getTypeNameFromRef({
typeRef: returnTypeRef,
isInput: false,
isRequired: false,
});
const args = {
...commonArgs,
};
// eslint-disable-next-line prefer-const
let entitySetPath = (_a = boundFunctionObj.attributes.EntitySetPath) === null || _a === void 0 ? void 0 : _a.split('/')[0];
let field;
let boundEntityTypeName;
(_b = boundFunctionObj.Parameter) === null || _b === void 0 ? void 0 : _b.forEach((parameterObj) => {
const parameterName = parameterObj.attributes.Name;
const parameterTypeRef = parameterObj.attributes.Type;
const isRequired = parameterObj.attributes.Nullable === 'false';
const parameterTypeName = getTypeNameFromRef({
typeRef: parameterTypeRef,
isInput: true,
isRequired,
});
// If entitySetPath is not available, take first parameter as entity
// The first segment of the entity set path must match the binding parameter name
// (see: http://docs.oasis-open.org/odata/odata-csdl-xml/v4.01/odata-csdl-xml-v4.01.html#_Toc38530388)
entitySetPath = (entitySetPath && entitySetPath.split('/')[0]) || parameterName;
if (entitySetPath === parameterName) {
boundEntityTypeName = getTypeNameFromRef({
typeRef: parameterTypeRef,
isInput: false,
isRequired: false,
})
.replace('[', '')
.replace(']', '');
field = {
type: returnType,
args,
resolve: async (root, args, context, info) => {
const url = new URL(root['@odata.id']);
url.href = urljoin(url.href, '/' + functionRef);
const argsEntries = Object.entries(args);
if (argsEntries.length) {
url.href += `(${argsEntries
.filter(argEntry => argEntry[0] !== 'queryOptions')
.map(([argName, value]) => [argName, typeof value === 'string' ? `'${value}'` : value])
.map(argEntry => argEntry.join('='))
.join(',')})`;
}
const parsedInfoFragment = graphqlParseResolveInfo.parseResolveInfo(info);
const searchParams = this.prepareSearchParams(parsedInfoFragment, info.schema);
searchParams === null || searchParams === void 0 ? void 0 : searchParams.forEach((value, key) => {
url.searchParams.set(key, value);
});
const urlString = getUrlString(url);
const method = 'GET';
const request = new fetch.Request(urlString, {
method,
headers: headersFactory({
root,
args,
context,
info,
env: crossHelpers.process.env,
}, method),
});
const response = await context[contextDataloaderName].load(request);
const responseText = await response.text();
return handleResponseText(responseText, urlString, info);
},
};
}
args[parameterName] = {
type: parameterTypeName,
};
});
const boundEntityType = schemaComposer.getAnyTC(boundEntityTypeName);
const boundEntityOtherType = getTCByTypeNames('I' + boundEntityTypeName, 'T' + boundEntityTypeName);
boundEntityType.addFields({
[functionName]: field,
});
boundEntityOtherType === null || boundEntityOtherType === void 0 ? void 0 : boundEntityOtherType.addFields({
[functionName]: field,
});
};
(_b = schemaObj.Function) === null || _b === void 0 ? void 0 : _b.forEach((functionObj) => {
var _a;
if (((_a = functionObj.attributes) === null || _a === void 0 ? void 0 : _a.IsBound) === 'true') {
handleBoundFunctionObj(functionObj);
}
else {
handleUnboundFunctionObj(functionObj);
}
});
const handleUnboundActionObj = (unboundActionObj) => {
var _a;
const actionName = unboundActionObj.attributes.Name;
schemaComposer.Mutation.addFields({
[actionName]: {
type: 'JSON',
args: {
...commonArgs,
},
resolve: async (root, args, context, info) => {
const url = new URL(baseUrl);
url.href = urljoin(url.href, '/' + actionName);
const urlString = getUrlString(url);
const method = 'POST';
const request = new fetch.Request(urlString, {
method,