@omnigraph/raml 1.0.0-alpha-3fc47d119.0 → 1.0.0-alpha-20230420181317-a95037648

package/README.md

@@ -1,8 +1,10 @@
 ## RAML (@omnigraph/raml)
 
-This package generates `GraphQLSchema` instance from **RAML API Document** (`.raml`) file located at a URL or FileSystem by resolving the JSON Schema dependencies. It uses `@omnigraph/json-schema` by generating the necessary configuration.
+This package generates `GraphQLSchema` instance from **RAML API Document** (`.raml`) file located at
+a URL or FileSystem by resolving the JSON Schema dependencies. It uses `@omnigraph/json-schema` by
+generating the necessary configuration.
 
-```yaml
+```yaml filename=".graphqlrc.yml"
 schema:
   myOmnigraph:
     loader: '@omnigraph/raml'

package/cjs/getJSONSchemaOptionsFromRAMLOptions.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJSONSchemaOptionsFromRAMLOptions = void 0;
+const tslib_1 = require("tslib");
+const json_machete_1 = require("json-machete");
+const to_json_schema_1 = tslib_1.__importDefault(require("to-json-schema"));
+const raml_1_parser_1 = require("@ardatan/raml-1-parser");
+const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
+const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+const utils_1 = require("@graphql-mesh/utils");
+const utils_2 = require("@graphql-tools/utils");
+const fetch_1 = require("@whatwg-node/fetch");
+const utils_js_1 = require("./utils.js");
+function resolveTraitsByIs(base) {
+    const allTraits = [];
+    for (const traitRef of base.is()) {
+        const traitNode = traitRef.trait();
+        if (traitNode) {
+            allTraits.push(traitNode);
+            allTraits.push(...resolveTraitsByIs(traitNode));
+        }
+    }
+    return allTraits;
+}
+/**
+ * Generates the options for JSON Schema Loader
+ * from RAML Loader options by extracting the JSON Schema references
+ * from RAML API Document
+ */
+async function getJSONSchemaOptionsFromRAMLOptions({ source, cwd: ramlFileCwd = cross_helpers_1.process.cwd(), operations: extraOperations, endpoint: forcedBaseUrl, fetch = fetch_1.fetch, schemaHeaders = {}, selectQueryOrMutationField = [], }) {
+    var _a, _b, _c, _d, _e, _f;
+    const fieldTypeMap = {};
+    for (const { fieldName, type } of selectQueryOrMutationField) {
+        fieldTypeMap[fieldName] = type;
+    }
+    const operations = extraOperations || [];
+    const ramlAbsolutePath = (0, json_machete_1.getAbsolutePath)(source, ramlFileCwd);
+    const schemaHeadersFactory = (0, string_interpolation_1.getInterpolatedHeadersFactory)(schemaHeaders);
+    const ramlAPI = (await (0, raml_1_parser_1.loadApi)(ramlAbsolutePath, [], {
+        httpResolver: {
+            getResourceAsync: async (url) => {
+                const fetchResponse = await fetch(url, {
+                    headers: schemaHeadersFactory({ env: cross_helpers_1.process.env }),
+                });
+                const content = await fetchResponse.text();
+                if (fetchResponse.status !== 200) {
+                    return {
+                        errorMessage: content,
+                    };
+                }
+                return {
+                    content,
+                };
+            },
+            getResource: () => {
+                throw new Error(`Sync fetching not available for URLs`);
+            },
+        },
+    }));
+    let endpoint = forcedBaseUrl;
+    if (!endpoint) {
+        endpoint = ramlAPI.baseUri().value();
+        for (const endpointParamNode of ramlAPI.baseUriParameters()) {
+            const paramName = endpointParamNode.name();
+            endpoint = endpoint.split(`{${paramName}}`).join(`{context.${paramName}}`);
+        }
+    }
+    const pathTypeMap = new Map();
+    const typePathMap = new Map();
+    for (const typeNode of ramlAPI.types()) {
+        const typeNodeJson = typeNode.toJSON();
+        for (const typeName in typeNodeJson) {
+            const { schemaPath } = typeNodeJson[typeName];
+            if (schemaPath) {
+                pathTypeMap.set(schemaPath, typeName);
+                typePathMap.set(typeName, schemaPath);
+            }
+        }
+    }
+    const cwd = (0, json_machete_1.getCwd)(ramlAbsolutePath);
+    const apiQueryParameters = [];
+    const apiBodyNodes = [];
+    const apiResponses = [];
+    for (const traitNode of ramlAPI.traits()) {
+        apiQueryParameters.push(...traitNode.queryParameters());
+        apiBodyNodes.push(...traitNode.body());
+        apiResponses.push(...traitNode.responses());
+        const nestedTraits = resolveTraitsByIs(traitNode);
+        for (const nestedTrait of nestedTraits) {
+            apiQueryParameters.push(...nestedTrait.queryParameters());
+            apiBodyNodes.push(...nestedTrait.body());
+            apiResponses.push(...nestedTrait.responses());
+        }
+    }
+    for (const resourceNode of ramlAPI.allResources()) {
+        const resourceQueryParameters = [...apiQueryParameters];
+        const resourceBodyNodes = [...apiBodyNodes];
+        const resourceResponses = [...apiResponses];
+        const resourceTraits = resolveTraitsByIs(resourceNode);
+        for (const traitNode of resourceTraits) {
+            apiQueryParameters.push(...traitNode.queryParameters());
+            apiBodyNodes.push(...traitNode.body());
+            apiResponses.push(...traitNode.responses());
+        }
+        for (const methodNode of resourceNode.methods()) {
+            const queryParameters = [...resourceQueryParameters];
+            const bodyNodes = [...resourceBodyNodes];
+            const responses = [...resourceResponses];
+            const traits = resolveTraitsByIs(methodNode);
+            for (const traitNode of traits) {
+                queryParameters.push(...traitNode.queryParameters());
+                bodyNodes.push(...traitNode.body());
+                responses.push(...traitNode.responses());
+            }
+            queryParameters.push(...methodNode.queryParameters());
+            bodyNodes.push(...methodNode.body());
+            responses.push(...methodNode.responses());
+            let requestSchema;
+            let requestTypeName;
+            const responseByStatusCode = {};
+            const method = methodNode.method().toUpperCase();
+            let fieldName = (_a = methodNode.displayName()) === null || _a === void 0 ? void 0 : _a.replace('GET_', '');
+            const description = ((_b = methodNode.description()) === null || _b === void 0 ? void 0 : _b.value()) || ((_c = resourceNode.description()) === null || _c === void 0 ? void 0 : _c.value());
+            const originalFullRelativeUrl = resourceNode.completeRelativeUri();
+            let fullRelativeUrl = originalFullRelativeUrl;
+            const argTypeMap = {};
+            const queryParamArgMap = {};
+            for (const uriParameterNode of resourceNode.uriParameters()) {
+                const paramName = uriParameterNode.name();
+                const argName = (0, utils_1.sanitizeNameForGraphQL)(paramName);
+                fullRelativeUrl = fullRelativeUrl.replace(`{${paramName}}`, `{args.${argName}}`);
+                const uriParameterNodeJson = uriParameterNode.toJSON();
+                if (uriParameterNodeJson.displayName) {
+                    uriParameterNodeJson.title = uriParameterNodeJson.displayName;
+                }
+                argTypeMap[argName] = uriParameterNodeJson;
+            }
+            for (const queryParameterNode of queryParameters) {
+                const parameterName = queryParameterNode.name();
+                const argName = (0, utils_1.sanitizeNameForGraphQL)(parameterName);
+                const queryParameterNodeJson = queryParameterNode.toJSON();
+                if (queryParameterNodeJson.displayName) {
+                    queryParameterNodeJson.title = queryParameterNodeJson.displayName;
+                }
+                queryParamArgMap[parameterName] = argName;
+                argTypeMap[argName] = queryParameterNodeJson;
+            }
+            for (const bodyNode of bodyNodes) {
+                if (bodyNode.name().includes('application/json')) {
+                    const bodyJson = bodyNode.toJSON();
+                    if (bodyJson.schemaPath) {
+                        const schemaPath = bodyJson.schemaPath;
+                        requestSchema = schemaPath;
+                        requestTypeName = pathTypeMap.get(schemaPath);
+                    }
+                    else if (bodyJson.type) {
+                        const typeName = (0, utils_2.asArray)(bodyJson.type)[0];
+                        requestTypeName = typeName;
+                        const schemaPath = typePathMap.get(typeName);
+                        requestSchema = schemaPath;
+                    }
+                }
+            }
+            for (const responseNode of responses) {
+                const statusCode = responseNode.code().value();
+                const responseNodeDescription = (_d = responseNode.description()) === null || _d === void 0 ? void 0 : _d.value();
+                for (const bodyNode of responseNode.body()) {
+                    if (bodyNode.name().includes('application/json')) {
+                        const bodyJson = bodyNode.toJSON();
+                        if (bodyJson.schemaPath) {
+                            const schemaPath = bodyJson.schemaPath;
+                            const typeName = pathTypeMap.get(schemaPath);
+                            if (schemaPath) {
+                                responseByStatusCode[statusCode] = {
+                                    responseSchema: schemaPath,
+                                    responseTypeName: typeName,
+                                };
+                            }
+                        }
+                        else if (bodyJson.type) {
+                            const typeName = (0, utils_2.asArray)(bodyJson.type)[0];
+                            const schemaPath = typePathMap.get(typeName);
+                            if (schemaPath) {
+                                responseByStatusCode[statusCode] = {
+                                    responseSchema: schemaPath,
+                                    responseTypeName: typeName,
+                                };
+                            }
+                        }
+                        if (!responseByStatusCode[statusCode] && bodyJson.example) {
+                            const responseSchema = (0, to_json_schema_1.default)(bodyJson.example, {
+                                required: false,
+                            });
+                            responseSchema.description = responseNodeDescription;
+                            responseByStatusCode[statusCode] = {
+                                responseSchema,
+                            };
+                        }
+                    }
+                }
+            }
+            fieldName =
+                fieldName ||
+                    (0, utils_js_1.getFieldNameFromPath)(originalFullRelativeUrl, method, (_e = responseByStatusCode['200']) === null || _e === void 0 ? void 0 : _e.responseTypeName);
+            if (fieldName) {
+                const graphQLFieldName = (0, utils_1.sanitizeNameForGraphQL)(fieldName);
+                const operationType = ((_f = fieldTypeMap[graphQLFieldName]) !== null && _f !== void 0 ? _f : method === 'GET') ? 'query' : 'mutation';
+                operations.push({
+                    type: operationType,
+                    field: graphQLFieldName,
+                    description,
+                    path: fullRelativeUrl,
+                    method,
+                    requestSchema,
+                    requestTypeName,
+                    responseByStatusCode,
+                    argTypeMap,
+                });
+            }
+        }
+    }
+    return {
+        operations,
+        endpoint,
+        cwd,
+        fetch,
+    };
+}
+exports.getJSONSchemaOptionsFromRAMLOptions = getJSONSchemaOptionsFromRAMLOptions;

package/cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJSONSchemaOptionsFromRAMLOptions = exports.default = void 0;
+const tslib_1 = require("tslib");
+var loadGraphQLSchemaFromRAML_js_1 = require("./loadGraphQLSchemaFromRAML.js");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return loadGraphQLSchemaFromRAML_js_1.loadGraphQLSchemaFromRAML; } });
+tslib_1.__exportStar(require("./loadGraphQLSchemaFromRAML.js"), exports);
+var getJSONSchemaOptionsFromRAMLOptions_js_1 = require("./getJSONSchemaOptionsFromRAMLOptions.js");
+Object.defineProperty(exports, "getJSONSchemaOptionsFromRAMLOptions", { enumerable: true, get: function () { return getJSONSchemaOptionsFromRAMLOptions_js_1.getJSONSchemaOptionsFromRAMLOptions; } });

package/cjs/loadGraphQLSchemaFromRAML.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processDirectives = exports.loadNonExecutableGraphQLSchemaFromRAML = exports.loadGraphQLSchemaFromRAML = void 0;
+const json_schema_1 = require("@omnigraph/json-schema");
+const getJSONSchemaOptionsFromRAMLOptions_js_1 = require("./getJSONSchemaOptionsFromRAMLOptions.js");
+/**
+ * Creates a local GraphQLSchema instance from a RAML API Document.
+ * Everytime this function is called, the RAML file and its dependencies will be resolved on runtime.
+ * If you want to avoid this, use `createBundle` function to create a bundle once and save it to a storage
+ * then load it with `loadGraphQLSchemaFromBundle`.
+ */
+async function loadGraphQLSchemaFromRAML(name, options) {
+    const extraJSONSchemaOptions = await (0, getJSONSchemaOptionsFromRAMLOptions_js_1.getJSONSchemaOptionsFromRAMLOptions)(options);
+    return (0, json_schema_1.loadGraphQLSchemaFromJSONSchemas)(name, {
+        ...options,
+        ...extraJSONSchemaOptions,
+    });
+}
+exports.loadGraphQLSchemaFromRAML = loadGraphQLSchemaFromRAML;
+async function loadNonExecutableGraphQLSchemaFromRAML(name, options) {
+    const extraJSONSchemaOptions = await (0, getJSONSchemaOptionsFromRAMLOptions_js_1.getJSONSchemaOptionsFromRAMLOptions)(options);
+    return (0, json_schema_1.loadNonExecutableGraphQLSchemaFromJSONSchemas)(name, {
+        ...options,
+        ...extraJSONSchemaOptions,
+    });
+}
+exports.loadNonExecutableGraphQLSchemaFromRAML = loadNonExecutableGraphQLSchemaFromRAML;
+var json_schema_2 = require("@omnigraph/json-schema");
+Object.defineProperty(exports, "processDirectives", { enumerable: true, get: function () { return json_schema_2.processDirectives; } });

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/utils.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFieldNameFromPath = void 0;
+const change_case_1 = require("change-case");
+function getFieldNameFromPath(path, method, typeName) {
+    // Replace identifiers with "by"
+    path = path.split('{').join('by_').split('}').join('');
+    const [actualPartsStr, allQueryPartsStr] = path.split('?');
+    const actualParts = actualPartsStr.split('/').filter(Boolean);
+    let fieldNameWithoutMethod = actualParts.join('_');
+    // If path doesn't give any field name without identifiers, we can use the return type with HTTP Method name
+    if ((!fieldNameWithoutMethod || fieldNameWithoutMethod.startsWith('by')) && typeName) {
+        // lowercase looks better in the schema
+        const prefix = (0, change_case_1.camelCase)(typeName);
+        if (fieldNameWithoutMethod) {
+            fieldNameWithoutMethod = prefix + '_' + fieldNameWithoutMethod;
+        }
+        else {
+            fieldNameWithoutMethod = prefix;
+        }
+    }
+    if (allQueryPartsStr) {
+        const queryParts = allQueryPartsStr.split('&');
+        for (const queryPart of queryParts) {
+            const [queryName] = queryPart.split('=');
+            fieldNameWithoutMethod += '_' + 'by' + '_' + queryName;
+        }
+    }
+    // get_ doesn't look good in field names
+    const methodPrefix = method.toLowerCase();
+    if (methodPrefix === 'get') {
+        return fieldNameWithoutMethod;
+    }
+    return methodPrefix + '_' + fieldNameWithoutMethod;
+}
+exports.getFieldNameFromPath = getFieldNameFromPath;

package/{index.mjs → esm/getJSONSchemaOptionsFromRAMLOptions.js}

@@ -1,48 +1,12 @@
-import { loadGraphQLSchemaFromJSONSchemas, createBundle as createBundle$1 } from '@omnigraph/json-schema';
-export { getGraphQLSchemaFromBundle } from '@omnigraph/json-schema';
-import { sanitizeNameForGraphQL } from '@graphql-mesh/utils';
 import { getAbsolutePath, getCwd } from 'json-machete';
-import { loadApi } from '@ardatan/raml-1-parser';
-import { fetch } from '@whatwg-node/fetch';
 import toJsonSchema from 'to-json-schema';
-import { asArray } from '@graphql-tools/utils';
-import { camelCase } from 'change-case';
-import { GraphQLEnumType } from 'graphql';
-import { getInterpolatedHeadersFactory } from '@graphql-mesh/string-interpolation';
+import { loadApi } from '@ardatan/raml-1-parser';
 import { process } from '@graphql-mesh/cross-helpers';
-
-function getFieldNameFromPath(path, method, typeName) {
-    // Replace identifiers with "by"
-    path = path.split('{').join('by_').split('}').join('');
-    const [actualPartsStr, allQueryPartsStr] = path.split('?');
-    const actualParts = actualPartsStr.split('/').filter(Boolean);
-    let fieldNameWithoutMethod = actualParts.join('_');
-    // If path doesn't give any field name without identifiers, we can use the return type with HTTP Method name
-    if ((!fieldNameWithoutMethod || fieldNameWithoutMethod.startsWith('by')) && typeName) {
-        // lowercase looks better in the schema
-        const prefix = camelCase(typeName);
-        if (fieldNameWithoutMethod) {
-            fieldNameWithoutMethod = prefix + '_' + fieldNameWithoutMethod;
-        }
-        else {
-            fieldNameWithoutMethod = prefix;
-        }
-    }
-    if (allQueryPartsStr) {
-        const queryParts = allQueryPartsStr.split('&');
-        for (const queryPart of queryParts) {
-            const [queryName] = queryPart.split('=');
-            fieldNameWithoutMethod += '_' + 'by' + '_' + queryName;
-        }
-    }
-    // get_ doesn't look good in field names
-    const methodPrefix = method.toLowerCase();
-    if (methodPrefix === 'get') {
-        return fieldNameWithoutMethod;
-    }
-    return methodPrefix + '_' + fieldNameWithoutMethod;
-}
-
+import { getInterpolatedHeadersFactory } from '@graphql-mesh/string-interpolation';
+import { sanitizeNameForGraphQL } from '@graphql-mesh/utils';
+import { asArray } from '@graphql-tools/utils';
+import { fetch as crossUndiciFetch } from '@whatwg-node/fetch';
+import { getFieldNameFromPath } from './utils.js';
 function resolveTraitsByIs(base) {
     const allTraits = [];
     for (const traitRef of base.is()) {
@@ -59,19 +23,19 @@ function resolveTraitsByIs(base) {
  * from RAML Loader options by extracting the JSON Schema references
  * from RAML API Document
  */
-async function getJSONSchemaOptionsFromRAMLOptions({ ramlFilePath, cwd: ramlFileCwd = process.cwd(), operations: extraOperations, baseUrl: forcedBaseUrl, fetch: fetch$1 = fetch, schemaHeaders = {}, selectQueryOrMutationField = [], }) {
-    var _a, _b, _c, _d, _e, _f, _g;
+export async function getJSONSchemaOptionsFromRAMLOptions({ source, cwd: ramlFileCwd = process.cwd(), operations: extraOperations, endpoint: forcedBaseUrl, fetch = crossUndiciFetch, schemaHeaders = {}, selectQueryOrMutationField = [], }) {
+    var _a, _b, _c, _d, _e, _f;
     const fieldTypeMap = {};
     for (const { fieldName, type } of selectQueryOrMutationField) {
         fieldTypeMap[fieldName] = type;
     }
     const operations = extraOperations || [];
-    const ramlAbsolutePath = getAbsolutePath(ramlFilePath, ramlFileCwd);
+    const ramlAbsolutePath = getAbsolutePath(source, ramlFileCwd);
     const schemaHeadersFactory = getInterpolatedHeadersFactory(schemaHeaders);
     const ramlAPI = (await loadApi(ramlAbsolutePath, [], {
         httpResolver: {
             getResourceAsync: async (url) => {
-                const fetchResponse = await fetch$1(url, {
+                const fetchResponse = await fetch(url, {
                     headers: schemaHeadersFactory({ env: process.env }),
                 });
                 const content = await fetchResponse.text();
@@ -89,12 +53,12 @@ async function getJSONSchemaOptionsFromRAMLOptions({ ramlFilePath, cwd: ramlFile
             },
         },
     }));
-    let baseUrl = forcedBaseUrl;
-    if (!baseUrl) {
-        baseUrl = ramlAPI.baseUri().value();
-        for (const baseUrlParamNode of ramlAPI.baseUriParameters()) {
-            const paramName = baseUrlParamNode.name();
-            baseUrl = baseUrl.split(`{${paramName}}`).join(`{context.${paramName}}`);
+    let endpoint = forcedBaseUrl;
+    if (!endpoint) {
+        endpoint = ramlAPI.baseUri().value();
+        for (const endpointParamNode of ramlAPI.baseUriParameters()) {
+            const paramName = endpointParamNode.name();
+            endpoint = endpoint.split(`{${paramName}}`).join(`{context.${paramName}}`);
         }
     }
     const pathTypeMap = new Map();
@@ -156,98 +120,26 @@ async function getJSONSchemaOptionsFromRAMLOptions({ ramlFilePath, cwd: ramlFile
             const originalFullRelativeUrl = resourceNode.completeRelativeUri();
             let fullRelativeUrl = originalFullRelativeUrl;
             const argTypeMap = {};
+            const queryParamArgMap = {};
             for (const uriParameterNode of resourceNode.uriParameters()) {
                 const paramName = uriParameterNode.name();
-                fullRelativeUrl = fullRelativeUrl.replace(`{${paramName}}`, `{args.${paramName}}`);
+                const argName = sanitizeNameForGraphQL(paramName);
+                fullRelativeUrl = fullRelativeUrl.replace(`{${paramName}}`, `{args.${argName}}`);
                 const uriParameterNodeJson = uriParameterNode.toJSON();
-                for (const typeName of asArray(uriParameterNodeJson.type)) {
-                    switch (typeName) {
-                        case 'number':
-                            argTypeMap[paramName] = 'Float';
-                            break;
-                        case 'boolean':
-                            argTypeMap[paramName] = 'Boolean';
-                            break;
-                        case 'integer':
-                            argTypeMap[paramName] = 'Int';
-                            break;
-                        default:
-                            argTypeMap[paramName] = 'String';
-                            break;
-                    }
-                }
-                /* raml pattern is different
-                if (uriParameterNodeJson.pattern) {
-                  const typeName = sanitizeNameForGraphQL(uriParameterNodeJson.displayName || `${fieldName}_${paramName}`);
-                  argTypeMap[paramName] = new RegularExpression(typeName, new RegExp(uriParameterNodeJson.pattern), {
-                    description: uriParameterNodeJson.description,
-                  });
-                }
-                */
-                if (uriParameterNodeJson.enum) {
-                    const typeName = sanitizeNameForGraphQL(uriParameterNodeJson.displayName || `${fieldName}_${paramName}`);
-                    const values = {};
-                    for (const value of asArray(uriParameterNodeJson.enum)) {
-                        let enumKey = sanitizeNameForGraphQL(value.toString());
-                        if (enumKey === 'false' || enumKey === 'true' || enumKey === 'null') {
-                            enumKey = enumKey.toUpperCase();
-                        }
-                        if (typeof enumKey === 'string' && enumKey.length === 0) {
-                            enumKey = '_';
-                        }
-                        values[enumKey] = {
-                            // Falsy values are ignored by GraphQL
-                            // eslint-disable-next-line no-unneeded-ternary
-                            value: value ? value : value === null || value === void 0 ? void 0 : value.toString(),
-                        };
-                    }
-                    argTypeMap[paramName] = new GraphQLEnumType({
-                        name: typeName,
-                        description: uriParameterNodeJson.description,
-                        values,
-                    });
-                }
-                if (uriParameterNodeJson.required) {
-                    argTypeMap[paramName] += '!';
+                if (uriParameterNodeJson.displayName) {
+                    uriParameterNodeJson.title = uriParameterNodeJson.displayName;
                 }
+                argTypeMap[argName] = uriParameterNodeJson;
             }
             for (const queryParameterNode of queryParameters) {
-                requestSchema = requestSchema || {
-                    type: 'object',
-                    properties: {},
-                    required: [],
-                };
                 const parameterName = queryParameterNode.name();
+                const argName = sanitizeNameForGraphQL(parameterName);
                 const queryParameterNodeJson = queryParameterNode.toJSON();
-                if (queryParameterNodeJson.required) {
-                    requestSchema.required.push(parameterName);
-                }
-                if (queryParameterNodeJson.enum) {
-                    requestSchema.properties[parameterName] = {
-                        type: 'string',
-                        enum: queryParameterNodeJson.enum,
-                    };
-                }
-                if (queryParameterNodeJson.type) {
-                    requestSchema.properties[parameterName] = {
-                        type: asArray(queryParameterNodeJson.type)[0] || 'string',
-                    };
-                }
-                else {
-                    requestSchema.properties[parameterName] = toJsonSchema((_d = queryParameterNodeJson.example) !== null && _d !== void 0 ? _d : queryParameterNodeJson.default, {
-                        required: false,
-                        strings: {
-                            detectFormat: true,
-                        },
-                    });
-                }
                 if (queryParameterNodeJson.displayName) {
-                    requestSchema.properties[parameterName].title = queryParameterNodeJson.displayName;
-                }
-                if (queryParameterNode.description) {
-                    requestSchema.properties[parameterName].description =
-                        queryParameterNodeJson.description;
+                    queryParameterNodeJson.title = queryParameterNodeJson.displayName;
                 }
+                queryParamArgMap[parameterName] = argName;
+                argTypeMap[argName] = queryParameterNodeJson;
             }
             for (const bodyNode of bodyNodes) {
                 if (bodyNode.name().includes('application/json')) {
@@ -267,7 +159,7 @@ async function getJSONSchemaOptionsFromRAMLOptions({ ramlFilePath, cwd: ramlFile
             }
             for (const responseNode of responses) {
                 const statusCode = responseNode.code().value();
-                const responseNodeDescription = (_e = responseNode.description()) === null || _e === void 0 ? void 0 : _e.value();
+                const responseNodeDescription = (_d = responseNode.description()) === null || _d === void 0 ? void 0 : _d.value();
                 for (const bodyNode of responseNode.body()) {
                     if (bodyNode.name().includes('application/json')) {
                         const bodyJson = bodyNode.toJSON();
@@ -305,10 +197,10 @@ async function getJSONSchemaOptionsFromRAMLOptions({ ramlFilePath, cwd: ramlFile
             }
             fieldName =
                 fieldName ||
-                    getFieldNameFromPath(originalFullRelativeUrl, method, (_f = responseByStatusCode['200']) === null || _f === void 0 ? void 0 : _f.responseTypeName);
+                    getFieldNameFromPath(originalFullRelativeUrl, method, (_e = responseByStatusCode['200']) === null || _e === void 0 ? void 0 : _e.responseTypeName);
             if (fieldName) {
                 const graphQLFieldName = sanitizeNameForGraphQL(fieldName);
-                const operationType = ((_g = fieldTypeMap[graphQLFieldName]) !== null && _g !== void 0 ? _g : method === 'GET') ? 'query' : 'mutation';
+                const operationType = ((_f = fieldTypeMap[graphQLFieldName]) !== null && _f !== void 0 ? _f : method === 'GET') ? 'query' : 'mutation';
                 operations.push({
                     type: operationType,
                     field: graphQLFieldName,
@@ -325,34 +217,8 @@ async function getJSONSchemaOptionsFromRAMLOptions({ ramlFilePath, cwd: ramlFile
     }
     return {
         operations,
-        baseUrl,
+        endpoint,
         cwd,
-        fetch: fetch$1,
+        fetch,
     };
 }
-
-/**
- * Creates a local GraphQLSchema instance from a RAML API Document.
- * Everytime this function is called, the RAML file and its dependencies will be resolved on runtime.
- * If you want to avoid this, use `createBundle` function to create a bundle once and save it to a storage
- * then load it with `loadGraphQLSchemaFromBundle`.
- */
-async function loadGraphQLSchemaFromRAML(name, options) {
-    const extraJSONSchemaOptions = await getJSONSchemaOptionsFromRAMLOptions(options);
-    return loadGraphQLSchemaFromJSONSchemas(name, {
-        ...options,
-        ...extraJSONSchemaOptions,
-    });
-}
-
-/**
- * Creates a bundle by downloading and resolving the internal references once
- * to load the schema locally later
- */
-async function createBundle(name, ramlLoaderOptions) {
-    const { operations, baseUrl, cwd, fetch } = await getJSONSchemaOptionsFromRAMLOptions(ramlLoaderOptions);
-    return createBundle$1(name, { ...ramlLoaderOptions, baseUrl, operations, cwd, fetch });
-}
-
-export default loadGraphQLSchemaFromRAML;
-export { createBundle, getJSONSchemaOptionsFromRAMLOptions };

package/{index.d.ts → esm/index.js}

@@ -1,4 +1,3 @@
-export { loadGraphQLSchemaFromRAML as default } from './loadGraphQLSchemaFromRAML';
-export { getJSONSchemaOptionsFromRAMLOptions } from './getJSONSchemaOptionsFromRAMLOptions';
-export { RAMLLoaderOptions } from './types';
-export * from './bundle';
+export { loadGraphQLSchemaFromRAML as default } from './loadGraphQLSchemaFromRAML.js';
+export * from './loadGraphQLSchemaFromRAML.js';
+export { getJSONSchemaOptionsFromRAMLOptions } from './getJSONSchemaOptionsFromRAMLOptions.js';

package/esm/loadGraphQLSchemaFromRAML.js

@@ -0,0 +1,23 @@
+import { loadGraphQLSchemaFromJSONSchemas, loadNonExecutableGraphQLSchemaFromJSONSchemas, } from '@omnigraph/json-schema';
+import { getJSONSchemaOptionsFromRAMLOptions } from './getJSONSchemaOptionsFromRAMLOptions.js';
+/**
+ * Creates a local GraphQLSchema instance from a RAML API Document.
+ * Everytime this function is called, the RAML file and its dependencies will be resolved on runtime.
+ * If you want to avoid this, use `createBundle` function to create a bundle once and save it to a storage
+ * then load it with `loadGraphQLSchemaFromBundle`.
+ */
+export async function loadGraphQLSchemaFromRAML(name, options) {
+    const extraJSONSchemaOptions = await getJSONSchemaOptionsFromRAMLOptions(options);
+    return loadGraphQLSchemaFromJSONSchemas(name, {
+        ...options,
+        ...extraJSONSchemaOptions,
+    });
+}
+export async function loadNonExecutableGraphQLSchemaFromRAML(name, options) {
+    const extraJSONSchemaOptions = await getJSONSchemaOptionsFromRAMLOptions(options);
+    return loadNonExecutableGraphQLSchemaFromJSONSchemas(name, {
+        ...options,
+        ...extraJSONSchemaOptions,
+    });
+}
+export { processDirectives } from '@omnigraph/json-schema';

package/esm/utils.js

@@ -0,0 +1,32 @@
+import { camelCase } from 'change-case';
+export function getFieldNameFromPath(path, method, typeName) {
+    // Replace identifiers with "by"
+    path = path.split('{').join('by_').split('}').join('');
+    const [actualPartsStr, allQueryPartsStr] = path.split('?');
+    const actualParts = actualPartsStr.split('/').filter(Boolean);
+    let fieldNameWithoutMethod = actualParts.join('_');
+    // If path doesn't give any field name without identifiers, we can use the return type with HTTP Method name
+    if ((!fieldNameWithoutMethod || fieldNameWithoutMethod.startsWith('by')) && typeName) {
+        // lowercase looks better in the schema
+        const prefix = camelCase(typeName);
+        if (fieldNameWithoutMethod) {
+            fieldNameWithoutMethod = prefix + '_' + fieldNameWithoutMethod;
+        }
+        else {
+            fieldNameWithoutMethod = prefix;
+        }
+    }
+    if (allQueryPartsStr) {
+        const queryParts = allQueryPartsStr.split('&');
+        for (const queryPart of queryParts) {
+            const [queryName] = queryPart.split('=');
+            fieldNameWithoutMethod += '_' + 'by' + '_' + queryName;
+        }
+    }
+    // get_ doesn't look good in field names
+    const methodPrefix = method.toLowerCase();
+    if (methodPrefix === 'get') {
+        return fieldNameWithoutMethod;
+    }
+    return methodPrefix + '_' + fieldNameWithoutMethod;
+}

package/package.json

@@ -1,22 +1,22 @@
 {
   "name": "@omnigraph/raml",
-  "version": "1.0.0-alpha-3fc47d119.0",
+  "version": "1.0.0-alpha-20230420181317-a95037648",
   "sideEffects": false,
   "peerDependencies": {
-    "@graphql-mesh/utils": "1.0.0-alpha-3fc47d119.0",
-    "graphql": "*"
+    "@graphql-mesh/cross-helpers": "^0.3.4",
+    "@graphql-mesh/utils": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-tools/utils": "^9.2.1",
+    "graphql": "*",
+    "tslib": "^2.4.0"
   },
   "dependencies": {
     "@ardatan/raml-1-parser": "1.1.69",
-    "@graphql-mesh/cross-helpers": "0.2.0",
-    "@graphql-mesh/string-interpolation": "0.3.0",
-    "@graphql-tools/utils": "8.8.0",
-    "@omnigraph/json-schema": "1.0.0-alpha-3fc47d119.0",
-    "@whatwg-node/fetch": "^0.0.2",
+    "@graphql-mesh/string-interpolation": "0.4.4",
+    "@omnigraph/json-schema": "1.0.0-alpha-20230420181317-a95037648",
+    "@whatwg-node/fetch": "^0.8.0",
     "change-case": "4.1.2",
-    "json-machete": "1.0.0-alpha-3fc47d119.0",
-    "to-json-schema": "0.2.5",
-    "tslib": "^2.4.0"
+    "json-machete": "1.0.0-alpha-20230420181317-a95037648",
+    "to-json-schema": "0.2.5"
   },
   "repository": {
     "type": "git",
@@ -24,21 +24,28 @@
     "directory": "packages/loaders/raml"
   },
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
-    },
-    "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/getJSONSchemaOptionsFromRAMLOptions.d.cts

@@ -0,0 +1,13 @@
+import { JSONSchemaOperationConfig } from '@omnigraph/json-schema';
+import { RAMLLoaderOptions } from './types.cjs';
+/**
+ * Generates the options for JSON Schema Loader
+ * from RAML Loader options by extracting the JSON Schema references
+ * from RAML API Document
+ */
+export declare function getJSONSchemaOptionsFromRAMLOptions({ source, cwd: ramlFileCwd, operations: extraOperations, endpoint: forcedBaseUrl, fetch, schemaHeaders, selectQueryOrMutationField, }: RAMLLoaderOptions): Promise<{
+    operations: JSONSchemaOperationConfig[];
+    cwd: string;
+    endpoint: string;
+    fetch?: WindowOrWorkerGlobalScope['fetch'];
+}>;

package/{getJSONSchemaOptionsFromRAMLOptions.d.ts → typings/getJSONSchemaOptionsFromRAMLOptions.d.ts}

@@ -1,13 +1,13 @@
 import { JSONSchemaOperationConfig } from '@omnigraph/json-schema';
-import { RAMLLoaderOptions } from './types';
+import { RAMLLoaderOptions } from './types.js';
 /**
  * Generates the options for JSON Schema Loader
  * from RAML Loader options by extracting the JSON Schema references
  * from RAML API Document
  */
-export declare function getJSONSchemaOptionsFromRAMLOptions({ ramlFilePath, cwd: ramlFileCwd, operations: extraOperations, baseUrl: forcedBaseUrl, fetch, schemaHeaders, selectQueryOrMutationField, }: RAMLLoaderOptions): Promise<{
+export declare function getJSONSchemaOptionsFromRAMLOptions({ source, cwd: ramlFileCwd, operations: extraOperations, endpoint: forcedBaseUrl, fetch, schemaHeaders, selectQueryOrMutationField, }: RAMLLoaderOptions): Promise<{
     operations: JSONSchemaOperationConfig[];
     cwd: string;
-    baseUrl: string;
+    endpoint: string;
     fetch?: WindowOrWorkerGlobalScope['fetch'];
 }>;

package/typings/index.d.cts

@@ -0,0 +1,4 @@
+export { loadGraphQLSchemaFromRAML as default } from './loadGraphQLSchemaFromRAML.cjs';
+export * from './loadGraphQLSchemaFromRAML.cjs';
+export { getJSONSchemaOptionsFromRAMLOptions } from './getJSONSchemaOptionsFromRAMLOptions.cjs';
+export { RAMLLoaderOptions } from './types.cjs';

package/typings/index.d.ts

@@ -0,0 +1,4 @@
+export { loadGraphQLSchemaFromRAML as default } from './loadGraphQLSchemaFromRAML.js';
+export * from './loadGraphQLSchemaFromRAML.js';
+export { getJSONSchemaOptionsFromRAMLOptions } from './getJSONSchemaOptionsFromRAMLOptions.js';
+export { RAMLLoaderOptions } from './types.js';

package/typings/loadGraphQLSchemaFromRAML.d.cts

@@ -0,0 +1,10 @@
+import { RAMLLoaderOptions } from './types.cjs';
+/**
+ * Creates a local GraphQLSchema instance from a RAML API Document.
+ * Everytime this function is called, the RAML file and its dependencies will be resolved on runtime.
+ * If you want to avoid this, use `createBundle` function to create a bundle once and save it to a storage
+ * then load it with `loadGraphQLSchemaFromBundle`.
+ */
+export declare function loadGraphQLSchemaFromRAML(name: string, options: RAMLLoaderOptions): Promise<import("graphql").GraphQLSchema>;
+export declare function loadNonExecutableGraphQLSchemaFromRAML(name: string, options: RAMLLoaderOptions): Promise<import("graphql").GraphQLSchema>;
+export { processDirectives } from '@omnigraph/json-schema';

package/{loadGraphQLSchemaFromRAML.d.ts → typings/loadGraphQLSchemaFromRAML.d.ts}

@@ -1,4 +1,4 @@
-import { RAMLLoaderOptions } from './types';
+import { RAMLLoaderOptions } from './types.js';
 /**
  * Creates a local GraphQLSchema instance from a RAML API Document.
  * Everytime this function is called, the RAML file and its dependencies will be resolved on runtime.
@@ -6,3 +6,5 @@ import { RAMLLoaderOptions } from './types';
  * then load it with `loadGraphQLSchemaFromBundle`.
  */
 export declare function loadGraphQLSchemaFromRAML(name: string, options: RAMLLoaderOptions): Promise<import("graphql").GraphQLSchema>;
+export declare function loadNonExecutableGraphQLSchemaFromRAML(name: string, options: RAMLLoaderOptions): Promise<import("graphql").GraphQLSchema>;
+export { processDirectives } from '@omnigraph/json-schema';

package/typings/types.d.cts

@@ -0,0 +1,9 @@
+import { JSONSchemaLoaderOptions } from '@omnigraph/json-schema';
+export interface RAMLLoaderOptions extends Partial<JSONSchemaLoaderOptions> {
+    source: string;
+    selectQueryOrMutationField?: RAMLLoaderSelectQueryOrMutationFieldConfig[];
+}
+export interface RAMLLoaderSelectQueryOrMutationFieldConfig {
+    type: 'query' | 'mutation' | 'Query' | 'Mutation';
+    fieldName: string;
+}

package/{types.d.ts → typings/types.d.ts}

@@ -1,9 +1,9 @@
 import { JSONSchemaLoaderOptions } from '@omnigraph/json-schema';
 export interface RAMLLoaderOptions extends Partial<JSONSchemaLoaderOptions> {
-    ramlFilePath: string;
+    source: string;
     selectQueryOrMutationField?: RAMLLoaderSelectQueryOrMutationFieldConfig[];
 }
 export interface RAMLLoaderSelectQueryOrMutationFieldConfig {
-    type: 'query' | 'mutation';
+    type: 'query' | 'mutation' | 'Query' | 'Mutation';
     fieldName: string;
 }

package/typings/utils.d.ts

@@ -0,0 +1 @@
+export declare function getFieldNameFromPath(path: string, method: string, typeName: string): string;

package/bundle.d.ts

@@ -1,8 +0,0 @@
-import { getGraphQLSchemaFromBundle, JSONSchemaLoaderBundle as RAMLLoaderBundle } from '@omnigraph/json-schema';
-import { RAMLLoaderOptions } from './types';
-/**
- * Creates a bundle by downloading and resolving the internal references once
- * to load the schema locally later
- */
-export declare function createBundle(name: string, ramlLoaderOptions: RAMLLoaderOptions): Promise<RAMLLoaderBundle>;
-export { getGraphQLSchemaFromBundle, RAMLLoaderBundle };

package/index.js

@@ -1,370 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-const jsonSchema = require('@omnigraph/json-schema');
-const utils = require('@graphql-mesh/utils');
-const jsonMachete = require('json-machete');
-const raml1Parser = require('@ardatan/raml-1-parser');
-const fetch = require('@whatwg-node/fetch');
-const toJsonSchema = _interopDefault(require('to-json-schema'));
-const utils$1 = require('@graphql-tools/utils');
-const changeCase = require('change-case');
-const graphql = require('graphql');
-const stringInterpolation = require('@graphql-mesh/string-interpolation');
-const crossHelpers = require('@graphql-mesh/cross-helpers');
-
-function getFieldNameFromPath(path, method, typeName) {
-    // Replace identifiers with "by"
-    path = path.split('{').join('by_').split('}').join('');
-    const [actualPartsStr, allQueryPartsStr] = path.split('?');
-    const actualParts = actualPartsStr.split('/').filter(Boolean);
-    let fieldNameWithoutMethod = actualParts.join('_');
-    // If path doesn't give any field name without identifiers, we can use the return type with HTTP Method name
-    if ((!fieldNameWithoutMethod || fieldNameWithoutMethod.startsWith('by')) && typeName) {
-        // lowercase looks better in the schema
-        const prefix = changeCase.camelCase(typeName);
-        if (fieldNameWithoutMethod) {
-            fieldNameWithoutMethod = prefix + '_' + fieldNameWithoutMethod;
-        }
-        else {
-            fieldNameWithoutMethod = prefix;
-        }
-    }
-    if (allQueryPartsStr) {
-        const queryParts = allQueryPartsStr.split('&');
-        for (const queryPart of queryParts) {
-            const [queryName] = queryPart.split('=');
-            fieldNameWithoutMethod += '_' + 'by' + '_' + queryName;
-        }
-    }
-    // get_ doesn't look good in field names
-    const methodPrefix = method.toLowerCase();
-    if (methodPrefix === 'get') {
-        return fieldNameWithoutMethod;
-    }
-    return methodPrefix + '_' + fieldNameWithoutMethod;
-}
-
-function resolveTraitsByIs(base) {
-    const allTraits = [];
-    for (const traitRef of base.is()) {
-        const traitNode = traitRef.trait();
-        if (traitNode) {
-            allTraits.push(traitNode);
-            allTraits.push(...resolveTraitsByIs(traitNode));
-        }
-    }
-    return allTraits;
-}
-/**
- * Generates the options for JSON Schema Loader
- * from RAML Loader options by extracting the JSON Schema references
- * from RAML API Document
- */
-async function getJSONSchemaOptionsFromRAMLOptions({ ramlFilePath, cwd: ramlFileCwd = crossHelpers.process.cwd(), operations: extraOperations, baseUrl: forcedBaseUrl, fetch: fetch$1 = fetch.fetch, schemaHeaders = {}, selectQueryOrMutationField = [], }) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    const fieldTypeMap = {};
-    for (const { fieldName, type } of selectQueryOrMutationField) {
-        fieldTypeMap[fieldName] = type;
-    }
-    const operations = extraOperations || [];
-    const ramlAbsolutePath = jsonMachete.getAbsolutePath(ramlFilePath, ramlFileCwd);
-    const schemaHeadersFactory = stringInterpolation.getInterpolatedHeadersFactory(schemaHeaders);
-    const ramlAPI = (await raml1Parser.loadApi(ramlAbsolutePath, [], {
-        httpResolver: {
-            getResourceAsync: async (url) => {
-                const fetchResponse = await fetch$1(url, {
-                    headers: schemaHeadersFactory({ env: crossHelpers.process.env }),
-                });
-                const content = await fetchResponse.text();
-                if (fetchResponse.status !== 200) {
-                    return {
-                        errorMessage: content,
-                    };
-                }
-                return {
-                    content,
-                };
-            },
-            getResource: () => {
-                throw new Error(`Sync fetching not available for URLs`);
-            },
-        },
-    }));
-    let baseUrl = forcedBaseUrl;
-    if (!baseUrl) {
-        baseUrl = ramlAPI.baseUri().value();
-        for (const baseUrlParamNode of ramlAPI.baseUriParameters()) {
-            const paramName = baseUrlParamNode.name();
-            baseUrl = baseUrl.split(`{${paramName}}`).join(`{context.${paramName}}`);
-        }
-    }
-    const pathTypeMap = new Map();
-    const typePathMap = new Map();
-    for (const typeNode of ramlAPI.types()) {
-        const typeNodeJson = typeNode.toJSON();
-        for (const typeName in typeNodeJson) {
-            const { schemaPath } = typeNodeJson[typeName];
-            if (schemaPath) {
-                pathTypeMap.set(schemaPath, typeName);
-                typePathMap.set(typeName, schemaPath);
-            }
-        }
-    }
-    const cwd = jsonMachete.getCwd(ramlAbsolutePath);
-    const apiQueryParameters = [];
-    const apiBodyNodes = [];
-    const apiResponses = [];
-    for (const traitNode of ramlAPI.traits()) {
-        apiQueryParameters.push(...traitNode.queryParameters());
-        apiBodyNodes.push(...traitNode.body());
-        apiResponses.push(...traitNode.responses());
-        const nestedTraits = resolveTraitsByIs(traitNode);
-        for (const nestedTrait of nestedTraits) {
-            apiQueryParameters.push(...nestedTrait.queryParameters());
-            apiBodyNodes.push(...nestedTrait.body());
-            apiResponses.push(...nestedTrait.responses());
-        }
-    }
-    for (const resourceNode of ramlAPI.allResources()) {
-        const resourceQueryParameters = [...apiQueryParameters];
-        const resourceBodyNodes = [...apiBodyNodes];
-        const resourceResponses = [...apiResponses];
-        const resourceTraits = resolveTraitsByIs(resourceNode);
-        for (const traitNode of resourceTraits) {
-            apiQueryParameters.push(...traitNode.queryParameters());
-            apiBodyNodes.push(...traitNode.body());
-            apiResponses.push(...traitNode.responses());
-        }
-        for (const methodNode of resourceNode.methods()) {
-            const queryParameters = [...resourceQueryParameters];
-            const bodyNodes = [...resourceBodyNodes];
-            const responses = [...resourceResponses];
-            const traits = resolveTraitsByIs(methodNode);
-            for (const traitNode of traits) {
-                queryParameters.push(...traitNode.queryParameters());
-                bodyNodes.push(...traitNode.body());
-                responses.push(...traitNode.responses());
-            }
-            queryParameters.push(...methodNode.queryParameters());
-            bodyNodes.push(...methodNode.body());
-            responses.push(...methodNode.responses());
-            let requestSchema;
-            let requestTypeName;
-            const responseByStatusCode = {};
-            const method = methodNode.method().toUpperCase();
-            let fieldName = (_a = methodNode.displayName()) === null || _a === void 0 ? void 0 : _a.replace('GET_', '');
-            const description = ((_b = methodNode.description()) === null || _b === void 0 ? void 0 : _b.value()) || ((_c = resourceNode.description()) === null || _c === void 0 ? void 0 : _c.value());
-            const originalFullRelativeUrl = resourceNode.completeRelativeUri();
-            let fullRelativeUrl = originalFullRelativeUrl;
-            const argTypeMap = {};
-            for (const uriParameterNode of resourceNode.uriParameters()) {
-                const paramName = uriParameterNode.name();
-                fullRelativeUrl = fullRelativeUrl.replace(`{${paramName}}`, `{args.${paramName}}`);
-                const uriParameterNodeJson = uriParameterNode.toJSON();
-                for (const typeName of utils$1.asArray(uriParameterNodeJson.type)) {
-                    switch (typeName) {
-                        case 'number':
-                            argTypeMap[paramName] = 'Float';
-                            break;
-                        case 'boolean':
-                            argTypeMap[paramName] = 'Boolean';
-                            break;
-                        case 'integer':
-                            argTypeMap[paramName] = 'Int';
-                            break;
-                        default:
-                            argTypeMap[paramName] = 'String';
-                            break;
-                    }
-                }
-                /* raml pattern is different
-                if (uriParameterNodeJson.pattern) {
-                  const typeName = sanitizeNameForGraphQL(uriParameterNodeJson.displayName || `${fieldName}_${paramName}`);
-                  argTypeMap[paramName] = new RegularExpression(typeName, new RegExp(uriParameterNodeJson.pattern), {
-                    description: uriParameterNodeJson.description,
-                  });
-                }
-                */
-                if (uriParameterNodeJson.enum) {
-                    const typeName = utils.sanitizeNameForGraphQL(uriParameterNodeJson.displayName || `${fieldName}_${paramName}`);
-                    const values = {};
-                    for (const value of utils$1.asArray(uriParameterNodeJson.enum)) {
-                        let enumKey = utils.sanitizeNameForGraphQL(value.toString());
-                        if (enumKey === 'false' || enumKey === 'true' || enumKey === 'null') {
-                            enumKey = enumKey.toUpperCase();
-                        }
-                        if (typeof enumKey === 'string' && enumKey.length === 0) {
-                            enumKey = '_';
-                        }
-                        values[enumKey] = {
-                            // Falsy values are ignored by GraphQL
-                            // eslint-disable-next-line no-unneeded-ternary
-                            value: value ? value : value === null || value === void 0 ? void 0 : value.toString(),
-                        };
-                    }
-                    argTypeMap[paramName] = new graphql.GraphQLEnumType({
-                        name: typeName,
-                        description: uriParameterNodeJson.description,
-                        values,
-                    });
-                }
-                if (uriParameterNodeJson.required) {
-                    argTypeMap[paramName] += '!';
-                }
-            }
-            for (const queryParameterNode of queryParameters) {
-                requestSchema = requestSchema || {
-                    type: 'object',
-                    properties: {},
-                    required: [],
-                };
-                const parameterName = queryParameterNode.name();
-                const queryParameterNodeJson = queryParameterNode.toJSON();
-                if (queryParameterNodeJson.required) {
-                    requestSchema.required.push(parameterName);
-                }
-                if (queryParameterNodeJson.enum) {
-                    requestSchema.properties[parameterName] = {
-                        type: 'string',
-                        enum: queryParameterNodeJson.enum,
-                    };
-                }
-                if (queryParameterNodeJson.type) {
-                    requestSchema.properties[parameterName] = {
-                        type: utils$1.asArray(queryParameterNodeJson.type)[0] || 'string',
-                    };
-                }
-                else {
-                    requestSchema.properties[parameterName] = toJsonSchema((_d = queryParameterNodeJson.example) !== null && _d !== void 0 ? _d : queryParameterNodeJson.default, {
-                        required: false,
-                        strings: {
-                            detectFormat: true,
-                        },
-                    });
-                }
-                if (queryParameterNodeJson.displayName) {
-                    requestSchema.properties[parameterName].title = queryParameterNodeJson.displayName;
-                }
-                if (queryParameterNode.description) {
-                    requestSchema.properties[parameterName].description =
-                        queryParameterNodeJson.description;
-                }
-            }
-            for (const bodyNode of bodyNodes) {
-                if (bodyNode.name().includes('application/json')) {
-                    const bodyJson = bodyNode.toJSON();
-                    if (bodyJson.schemaPath) {
-                        const schemaPath = bodyJson.schemaPath;
-                        requestSchema = schemaPath;
-                        requestTypeName = pathTypeMap.get(schemaPath);
-                    }
-                    else if (bodyJson.type) {
-                        const typeName = utils$1.asArray(bodyJson.type)[0];
-                        requestTypeName = typeName;
-                        const schemaPath = typePathMap.get(typeName);
-                        requestSchema = schemaPath;
-                    }
-                }
-            }
-            for (const responseNode of responses) {
-                const statusCode = responseNode.code().value();
-                const responseNodeDescription = (_e = responseNode.description()) === null || _e === void 0 ? void 0 : _e.value();
-                for (const bodyNode of responseNode.body()) {
-                    if (bodyNode.name().includes('application/json')) {
-                        const bodyJson = bodyNode.toJSON();
-                        if (bodyJson.schemaPath) {
-                            const schemaPath = bodyJson.schemaPath;
-                            const typeName = pathTypeMap.get(schemaPath);
-                            if (schemaPath) {
-                                responseByStatusCode[statusCode] = {
-                                    responseSchema: schemaPath,
-                                    responseTypeName: typeName,
-                                };
-                            }
-                        }
-                        else if (bodyJson.type) {
-                            const typeName = utils$1.asArray(bodyJson.type)[0];
-                            const schemaPath = typePathMap.get(typeName);
-                            if (schemaPath) {
-                                responseByStatusCode[statusCode] = {
-                                    responseSchema: schemaPath,
-                                    responseTypeName: typeName,
-                                };
-                            }
-                        }
-                        if (!responseByStatusCode[statusCode] && bodyJson.example) {
-                            const responseSchema = toJsonSchema(bodyJson.example, {
-                                required: false,
-                            });
-                            responseSchema.description = responseNodeDescription;
-                            responseByStatusCode[statusCode] = {
-                                responseSchema,
-                            };
-                        }
-                    }
-                }
-            }
-            fieldName =
-                fieldName ||
-                    getFieldNameFromPath(originalFullRelativeUrl, method, (_f = responseByStatusCode['200']) === null || _f === void 0 ? void 0 : _f.responseTypeName);
-            if (fieldName) {
-                const graphQLFieldName = utils.sanitizeNameForGraphQL(fieldName);
-                const operationType = ((_g = fieldTypeMap[graphQLFieldName]) !== null && _g !== void 0 ? _g : method === 'GET') ? 'query' : 'mutation';
-                operations.push({
-                    type: operationType,
-                    field: graphQLFieldName,
-                    description,
-                    path: fullRelativeUrl,
-                    method,
-                    requestSchema,
-                    requestTypeName,
-                    responseByStatusCode,
-                    argTypeMap,
-                });
-            }
-        }
-    }
-    return {
-        operations,
-        baseUrl,
-        cwd,
-        fetch: fetch$1,
-    };
-}
-
-/**
- * Creates a local GraphQLSchema instance from a RAML API Document.
- * Everytime this function is called, the RAML file and its dependencies will be resolved on runtime.
- * If you want to avoid this, use `createBundle` function to create a bundle once and save it to a storage
- * then load it with `loadGraphQLSchemaFromBundle`.
- */
-async function loadGraphQLSchemaFromRAML(name, options) {
-    const extraJSONSchemaOptions = await getJSONSchemaOptionsFromRAMLOptions(options);
-    return jsonSchema.loadGraphQLSchemaFromJSONSchemas(name, {
-        ...options,
-        ...extraJSONSchemaOptions,
-    });
-}
-
-/**
- * Creates a bundle by downloading and resolving the internal references once
- * to load the schema locally later
- */
-async function createBundle(name, ramlLoaderOptions) {
-    const { operations, baseUrl, cwd, fetch } = await getJSONSchemaOptionsFromRAMLOptions(ramlLoaderOptions);
-    return jsonSchema.createBundle(name, { ...ramlLoaderOptions, baseUrl, operations, cwd, fetch });
-}
-
-Object.defineProperty(exports, 'getGraphQLSchemaFromBundle', {
-    enumerable: true,
-    get: function () {
-        return jsonSchema.getGraphQLSchemaFromBundle;
-    }
-});
-exports.createBundle = createBundle;
-exports.default = loadGraphQLSchemaFromRAML;
-exports.getJSONSchemaOptionsFromRAMLOptions = getJSONSchemaOptionsFromRAMLOptions;