@avantstay/graphql-ts-client 11.0.0-beta.1 → 12.0.0

package/README.md

@@ -33,10 +33,10 @@ import { myAwesomeApi, AssetType, Granularity, OnBoardingStage } from './myAweso
 async function somewhereOverTheRainbow() {
   // Set an specific header if needed
   myAwesomeApi.setHeader('Authorization', 'Bearer 010101010101')
-  
+
   // You can also change the API url
   myAwesomeApi.setUrl('https://my-runtime-url.com/graphql')
-  
+
   // And configure how retrials should work
   myAwesomeApi.setRetryConfig({
     max: 3,
@@ -44,12 +44,12 @@ async function somewhereOverTheRainbow() {
       // do something before retrying
     },
   })
-  
+
   // Adding response listeners is also possible
   myAwesomeApi.addResponseListener(({ queryName, query, variables, response }) => {
     // do something whenever a request is responded
   })
-  
+
   const response = await myAwesomeApi.queries.globalIndicators({
     // Optionally you can define an alias for this request
     __alias: 'myCustomGlobalIndicators',

package/dist/chunk-I4QOADOI.mjs

@@ -0,0 +1,27 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/types.ts
+var GraphQLClientError = class extends Error {
+  constructor(responseData) {
+    super();
+    this.responseData = responseData;
+    Object.setPrototypeOf(this, GraphQLClientError.prototype);
+  }
+  get message() {
+    return this.response.errors.map((it) => it.message).join(";\n");
+  }
+  get response() {
+    return this.responseData;
+  }
+};
+
+export {
+  __require,
+  GraphQLClientError
+};

package/dist/endpoint.d.ts

@@ -1,4 +1,4 @@
-import { C as ClientConfig, I as IResponseListener, E as Endpoint } from './types-4ada662b.js';
+import { C as ClientConfig, I as IResponseListener, E as Endpoint } from './types-23d2d6aa.js';
 
 declare const getApiEndpointCreator: (apiConfig: {
     getClient: () => ClientConfig;

package/dist/endpoint.js

@@ -603,7 +603,8 @@ function jsonToGraphQLQuery(param) {
     var alias = jsonQuery.__alias;
     var newJsonQuery = cloneDeep((0, import_omit.default)(jsonQuery, [
         "__alias",
-        "__headers"
+        "__headers",
+        "__url"
     ]));
     extractVariables({
         jsonQuery: _defineProperty({}, queryName, newJsonQuery),
@@ -723,11 +724,13 @@ var getApiEndpointCreator = function(apiConfig) {
     return function(kind, queryName) {
         var rawEndpoint = function() {
             var _ref = _asyncToGenerator(function(failureMode, jsonQuery) {
-                var _jsonQuery___alias, alias, _jsonQuery___retry, shouldRetry, _jsonQuery___headers, requestHeaders, _jsonToGraphQLQuery, query, variables, start, logOptions, responseListenerData, _ref, data, errors, warnings, headers, status, response, error;
+                var clientConfig, _jsonQuery___alias, alias, _jsonQuery___url, url, _jsonQuery___retry, shouldRetry, _jsonQuery___headers, requestHeaders, _jsonToGraphQLQuery, query, variables, start, logOptions, responseListenerData, _ref, data, errors, warnings, headers, status, response, error;
                 return __generator(this, function(_state) {
                     switch(_state.label){
                         case 0:
+                            clientConfig = apiConfig.getClient();
                             alias = (_jsonQuery___alias = jsonQuery === null || jsonQuery === void 0 ? void 0 : jsonQuery.__alias) !== null && _jsonQuery___alias !== void 0 ? _jsonQuery___alias : queryName;
+                            url = (_jsonQuery___url = jsonQuery === null || jsonQuery === void 0 ? void 0 : jsonQuery.__url) !== null && _jsonQuery___url !== void 0 ? _jsonQuery___url : clientConfig.url;
                             shouldRetry = (_jsonQuery___retry = jsonQuery === null || jsonQuery === void 0 ? void 0 : jsonQuery.__retry) !== null && _jsonQuery___retry !== void 0 ? _jsonQuery___retry : true;
                             requestHeaders = (_jsonQuery___headers = jsonQuery === null || jsonQuery === void 0 ? void 0 : jsonQuery.__headers) !== null && _jsonQuery___headers !== void 0 ? _jsonQuery___headers : {};
                             _jsonToGraphQLQuery = jsonToGraphQLQuery({
@@ -764,7 +767,9 @@ var getApiEndpointCreator = function(apiConfig) {
                                     shouldRetry: shouldRetry,
                                     failureMode: failureMode,
                                     queryName: alias,
-                                    client: apiConfig.getClient(),
+                                    client: _objectSpreadProps(_objectSpread({}, clientConfig), {
+                                        url: url
+                                    }),
                                     requestHeaders: requestHeaders,
                                     query: query,
                                     variables: variables,

package/dist/endpoint.mjs

@@ -0,0 +1,275 @@
+import {
+  GraphQLClientError,
+  __require
+} from "./chunk-I4QOADOI.mjs";
+
+// src/endpoint.ts
+import memoize from "moize";
+
+// src/graphqlRequest.ts
+import _axios from "axios";
+var sleep = (ms = 0) => new Promise((resolve) => {
+  setTimeout(() => resolve(), ms);
+});
+async function graphqlRequest({
+  shouldRetry = true,
+  axios = _axios,
+  queryName,
+  client,
+  query,
+  requestHeaders = {},
+  variables,
+  failureMode,
+  errorsParser
+}) {
+  let lastResponse;
+  const maxRetrials = shouldRetry ? client.retryConfig.max : 0;
+  for (let trial = 0; true; trial++) {
+    const infoParams = {
+      _q: queryName,
+      ...trial > 0 ? { _retrial: trial + 1 } : {}
+    };
+    const {
+      data: responseData = {},
+      headers,
+      status
+    } = await axios.post(
+      client.url,
+      { query, variables, operationName: queryName },
+      {
+        params: infoParams,
+        headers: {
+          "Content-Type": "application/json",
+          ...client.headers,
+          ...requestHeaders
+        },
+        validateStatus: () => true
+      }
+    );
+    let { data, errors, warnings } = responseData;
+    if (status >= 400 && !errors?.length) {
+      errors = [{ message: `Request "${queryName}" failed with status ${status}` }];
+    }
+    lastResponse = {
+      errors: errorsParser ? errorsParser(errors) : errors,
+      data,
+      warnings,
+      headers,
+      status
+    };
+    if (!errors?.length) {
+      break;
+    } else if (trial < maxRetrials && typeof client.retryConfig?.before === "function") {
+      await client.retryConfig?.before({
+        queryName,
+        query,
+        variables,
+        response: lastResponse
+      });
+      if (client.retryConfig.waitBeforeRetry) {
+        await sleep(client.retryConfig.waitBeforeRetry);
+      }
+    } else if (trial >= maxRetrials) {
+      break;
+    }
+  }
+  if (failureMode === "loud" && lastResponse.errors && lastResponse.errors?.length) {
+    throw new GraphQLClientError(lastResponse);
+  }
+  return lastResponse;
+}
+
+// src/jsonToGraphQLQuery.ts
+import omit from "lodash/omit";
+var VAR_PREFIX = "@@VAR@@";
+var VAR_PREFIX_LENGTH = VAR_PREFIX.length;
+var fromEntries = __require("lodash/fromPairs");
+var entries = __require("lodash/toPairs");
+var cloneDeep = __require("lodash/cloneDeep");
+function jsonToGraphQLQuery({
+  kind,
+  queryName,
+  jsonQuery = {},
+  typesTree
+}) {
+  const variablesData = {};
+  const alias = jsonQuery.__alias;
+  const newJsonQuery = cloneDeep(omit(jsonQuery, ["__alias", "__headers", "__url"]));
+  extractVariables({
+    jsonQuery: { [queryName]: newJsonQuery },
+    variables: variablesData,
+    parentType: kind === "query" ? typesTree.Query : typesTree.Mutation
+  });
+  const variableItems = Object.values(variablesData).reduce(
+    (variablesObj, variables2) => {
+      variables2.forEach((variable, index) => {
+        const name = variable.update(variables2.length > 1 ? index : void 0);
+        variablesObj[name] = { type: variable.type, value: variable.value };
+      });
+      return variablesObj;
+    },
+    {}
+  );
+  const variablesQuery = Object.keys(variableItems).length ? `(${entries(variableItems).map(([queryName2, { type }]) => `$${queryName2}: ${type}`).join(", ")})` : "";
+  const query = `${kind} ${alias || queryName}${variablesQuery} { ${alias ? `${alias}:` : ""}${queryName}${toGraphql(
+    newJsonQuery
+  )} }`;
+  const variables = fromEntries(entries(variableItems).map(([k, v]) => [k, v.value]));
+  return {
+    query,
+    variables
+  };
+}
+function extractVariables({
+  jsonQuery,
+  variables,
+  parentType
+}) {
+  if (!parentType)
+    return;
+  if (jsonQuery.__args) {
+    Object.keys(jsonQuery.__args).forEach((k) => {
+      if (typeof jsonQuery.__args[k] === "string" && jsonQuery.__args[k].startsWith(VAR_PREFIX))
+        return;
+      if (jsonQuery.__args[k] === void 0)
+        return;
+      const variableName = k;
+      if (!variables[variableName]) {
+        variables[variableName] = [];
+      }
+      variables[variableName].push({
+        name: variableName,
+        type: parentType.__args[k],
+        value: jsonQuery.__args[k],
+        update: (index) => {
+          const name = `${variableName}${index !== void 0 ? `_${index}` : ""}`;
+          jsonQuery.__args[k] = `${VAR_PREFIX}$${name}`;
+          return name;
+        }
+      });
+      jsonQuery.__args[k] = VAR_PREFIX;
+    });
+  }
+  Object.keys(jsonQuery).filter((k) => k !== "__args" && typeof jsonQuery[k] === "object").forEach(
+    (k) => extractVariables({
+      jsonQuery: jsonQuery[k],
+      variables,
+      parentType: parentType.hasOwnProperty(k) ? parentType[k] : parentType.__fields ? parentType.__fields[k] : void 0
+    })
+  );
+}
+function toGraphql(jsonQuery) {
+  const fields = entries(jsonQuery).filter(([k, v]) => k !== "__args" && v !== false && v !== void 0).map(([k, v]) => typeof v === "object" ? `${k}${toGraphql(v)}` : k).join(" ");
+  const validArgs = jsonQuery.__args ? entries(jsonQuery.__args).filter(([_, v]) => v !== void 0) : [];
+  const argsQuery = validArgs.length ? `(${validArgs.map(([k, v]) => `${k}:${v.substr(VAR_PREFIX_LENGTH)}`).join(",")})` : "";
+  return `${argsQuery} ${fields ? `{ ${fields} }` : ""}`;
+}
+
+// src/logging.ts
+function logRequest(logInfo) {
+  let identifier = `%c#graphql-ts-client ${logInfo.kind} ${logInfo.queryName}`;
+  let identifierStyles = "color: transparent; font-size: 0px";
+  console.groupCollapsed(
+    `%c#graphql-ts-client %c${logInfo.kind} %c${logInfo.queryName} %c(${logInfo.duration.toFixed(2)}ms)`,
+    "color: #f90",
+    "color: #999",
+    `color: ${logInfo.response ? "unset" : "#f00"}; font-weight: bold`,
+    "color: #999"
+  );
+  console.groupCollapsed(`%cQuery ${identifier}`, "color: #999", identifierStyles);
+  console.log(logInfo.formatGraphQL(logInfo.query) + identifier, identifierStyles);
+  console.groupEnd();
+  console.groupCollapsed(`%cVariables ${identifier}`, "color: #999", identifierStyles);
+  console.log(JSON.stringify(logInfo.variables, null, "  ") + identifier, identifierStyles);
+  console.groupEnd();
+  console.groupCollapsed(`%cTrace ${identifier}`, "color: #999", identifierStyles);
+  console.trace(identifier, identifierStyles);
+  console.groupEnd();
+  if (logInfo.response) {
+    console.log("%cResponse".padEnd(15, " ") + identifier, "color: #999", identifierStyles, logInfo.response);
+  }
+  if (logInfo.error) {
+    console.log("%cError".padEnd(15, " ") + identifier, "color: #999", identifierStyles, logInfo.error);
+  }
+  console.groupEnd();
+}
+
+// src/endpoint.ts
+var executeListeners = (listeners, data) => setTimeout(() => listeners.forEach((runResponseListener) => runResponseListener(data)));
+var getApiEndpointCreator = (apiConfig) => (kind, queryName) => {
+  const rawEndpoint = async (failureMode, jsonQuery) => {
+    const clientConfig = apiConfig.getClient();
+    const alias = jsonQuery?.__alias ?? queryName;
+    const url = jsonQuery?.__url ?? clientConfig.url;
+    const shouldRetry = jsonQuery?.__retry ?? true;
+    const requestHeaders = jsonQuery?.__headers ?? {};
+    const { query, variables } = jsonToGraphQLQuery({ kind, queryName, jsonQuery, typesTree: apiConfig.typesTree });
+    const start = +new Date();
+    const logOptions = {
+      kind,
+      queryName: alias,
+      formatGraphQL: apiConfig.formatGraphQL,
+      requestHeaders,
+      query,
+      variables
+    };
+    const responseListenerData = {
+      queryName: alias,
+      query: apiConfig.formatGraphQL(query),
+      variables
+    };
+    try {
+      const { data, errors, warnings, headers, status } = await graphqlRequest({
+        shouldRetry,
+        failureMode,
+        queryName: alias,
+        client: { ...clientConfig, url },
+        requestHeaders,
+        query,
+        variables,
+        errorsParser: apiConfig.errorsParser
+      });
+      const response = { data, warnings, headers, status, errors };
+      if (apiConfig.verbose && globalThis.document) {
+        logRequest({
+          ...logOptions,
+          response,
+          duration: +new Date() - start
+        });
+      }
+      executeListeners(apiConfig.responseListeners, {
+        ...responseListenerData,
+        response
+      });
+      return { data: data?.[alias], errors, warnings, headers, status };
+    } catch (error) {
+      if (apiConfig.verbose && globalThis.document) {
+        logRequest({
+          ...logOptions,
+          error,
+          duration: +new Date() - start
+        });
+      }
+      executeListeners(apiConfig.responseListeners, {
+        ...responseListenerData,
+        response: error.response
+      });
+      throw error;
+    }
+  };
+  const endpoint = async (jsonQuery) => {
+    const { data } = await rawEndpoint("loud", jsonQuery);
+    return data;
+  };
+  const memoizeeOptions = {
+    maxAge: apiConfig.maxAge,
+    isSerialized: true
+  };
+  endpoint.raw = rawEndpoint.bind(null, "silent");
+  endpoint.memo = memoize(endpoint, memoizeeOptions);
+  endpoint.memoRaw = memoize(endpoint.raw, memoizeeOptions);
+  return endpoint;
+};
+export {
+  getApiEndpointCreator
+};

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { PathLike } from 'fs';
-export { C as ClientConfig, c as DeepReplace, D as Defined, E as Endpoint, G as GraphQLClientError, I as IResponseListener, J as JsonOutput, L as LogInfo, M as Maybe, P as Projection, d as RawEndpoint, b as Replacement, R as ResponseData, a as ResponseListenerInfo, U as Unpacked } from './types-4ada662b.js';
+import { T as TypescriptClientOutput } from './types-23d2d6aa.js';
+export { C as ClientConfig, c as DeepReplace, D as Defined, E as Endpoint, G as GraphQLClientError, I as IResponseListener, J as JsonOutput, L as LogInfo, M as Maybe, P as Projection, d as RawEndpoint, b as Replacement, R as ResponseData, a as ResponseListenerInfo, T as TypescriptClientOutput, U as Unpacked } from './types-23d2d6aa.js';
 
 type IClientOptions = {
     output?: PathLike;
@@ -14,11 +15,7 @@ type IClientOptions = {
     skipCache?: boolean;
     errorsParser?: (errors: any[]) => any;
 };
-type Client = {
-    typings: string;
-    js: string;
-};
-declare function generateTypescriptClient({ introspectionEndpoint, ...options }: IClientOptions): Promise<Client>;
-declare function generateTypescriptClientFromSDL(SDL: string, options: IClientOptions): Client;
+declare function generateTypescriptClient({ introspectionEndpoint, ...options }: IClientOptions): Promise<TypescriptClientOutput>;
+declare function generateTypescriptClientFromSDL(SDL: string, options: IClientOptions): TypescriptClientOutput;
 
 export { generateTypescriptClient, generateTypescriptClientFromSDL };

package/dist/index.js

@@ -477,7 +477,7 @@ var import_case = __toESM(require("case"));
 var esbuild = __toESM(require("esbuild"));
 var fs = __toESM(require("fs"));
 var import_graphql = require("graphql");
-var import_lodash = require("lodash");
+var import_kebabCase = __toESM(require("lodash/kebabCase"));
 var import_orderBy = __toESM(require("lodash/orderBy"));
 var import_set = __toESM(require("lodash/set"));
 var import_md5 = __toESM(require("md5"));
@@ -487,65 +487,52 @@ var prettier = __toESM(require("prettier"));
 // package.json
 var package_default = {
     name: "@avantstay/graphql-ts-client",
-    version: "11.0.0-beta.1",
+    version: "12.0.0",
     description: "GraphQL Typescript Client Generator",
-    author: "Wellington Guimaraes",
-    license: "MIT",
-    main: "dist/index.js",
-    typings: "dist/index.d.ts",
-    scripts: {
-        build: "tsup src/index.ts src/endpoint.ts --dts",
-        test: "cross-env GQL_CLIENT_DIST_PATH='.' jest --watch",
-        prepublishOnly: "yarn build"
-    },
-    files: [
-        "dist",
-        "src"
-    ],
-    engines: {
-        node: ">=12"
-    },
+    homepage: "https://github.com/avantstay/graphql-ts-client",
     bugs: {
         url: "https://github.com/avantstay/graphql-ts-client/issues"
     },
-    homepage: "https://github.com/avantstay/graphql-ts-client#readme",
     repository: {
         type: "git",
         url: "git+https://github.com/avantstay/graphql-ts-client.git"
     },
-    peerDependencies: {},
-    prettier: {
-        trailingComma: "es5",
-        tabWidth: 2,
-        proseWrap: "always",
-        bracketSpacing: true,
-        jsxBracketSameLine: false,
-        semi: false,
-        singleQuote: true,
-        arrowParens: "avoid",
-        endOfLine: "lf",
-        printWidth: 130,
-        htmlWhitespaceSensitivity: "ignore",
-        jsxSingleQuote: false
-    },
-    module: "dist/graphql-ts-client.esm.js",
-    "size-limit": [
-        {
-            path: "dist/graphql-ts-client.cjs.production.min.js",
-            limit: "10 KB"
+    license: "MIT",
+    author: "Wellington Guimaraes",
+    contributors: [
+        "Felipe Pinheiro <felipe.pinheiro.90@hotmail.com>"
+    ],
+    exports: {
+        ".": {
+            import: "./dist/index.mjs",
+            require: "./dist/index.js",
+            types: "./dist/index.d.ts"
         },
-        {
-            path: "dist/graphql-ts-client.esm.js",
-            limit: "10 KB"
+        "./dist/endpoint": {
+            import: "./dist/endpoint.mjs",
+            require: "./dist/endpoint.js",
+            types: "./dist/endpoint.d.ts"
         }
+    },
+    main: "dist/index.js",
+    module: "dist/index.mjs",
+    typings: "dist/index.d.ts",
+    files: [
+        "dist",
+        "src"
     ],
+    scripts: {
+        build: "yarn tsup src/index.ts src/endpoint.ts --dts --format cjs,esm",
+        prepublishOnly: "yarn build",
+        test: "cross-env GQL_CLIENT_DIST_PATH='.' jest --watch"
+    },
     dependencies: {
         "@types/md5": "^2.3.2",
         axios: "^0.24.0",
         "axios-retry": "^3.2.4",
         case: "^1.6.3",
         esbuild: "^0.13.14",
-        graphql: "^15.6.0",
+        graphql: "^16.13.2",
         lodash: "^4.17.21",
         md5: "^2.3.0",
         moize: "^6.1.0",
@@ -574,9 +561,23 @@ var package_default = {
         tsup: "^6.5.0",
         typescript: "^4.9.4"
     },
+    peerDependencies: {},
+    engines: {
+        node: ">=12"
+    },
     publishConfig: {
         "@avantstay:registry": "https://registry.npmjs.org/"
-    }
+    },
+    "size-limit": [
+        {
+            path: "dist/graphql-ts-client.cjs.production.min.js",
+            limit: "10 KB"
+        },
+        {
+            path: "dist/graphql-ts-client.esm.js",
+            limit: "10 KB"
+        }
+    ]
 };
 // src/generateTypescriptClient.ts
 var tempDir = fs.realpathSync(import_os.default.tmpdir());
@@ -639,7 +640,7 @@ function gqlFieldToTypescript(field, param) {
                 selection: false
             });
         });
-        fieldTypeDefinition = "{ __headers?: {[key: string]: string}; __retry?: boolean; __alias?: string; __args".concat(fieldsOnArgs.every(function(arg) {
+        fieldTypeDefinition = "{ __headers?: {[key: string]: string}; __retry?: boolean; __alias?: string; __url?: string; __args".concat(fieldsOnArgs.every(function(arg) {
             return arg.isOptional;
         }) ? "?" : "", ": { ").concat(fieldsOnArgs.map(function(arg) {
             return arg.code;
@@ -679,7 +680,7 @@ function gqlEndpointToCode(kind, endpoint, codeOutputType) {
         selection: true
     });
     var argsType = endpoint.args && endpoint.args.length ? getArgsType(endpoint) : null;
-    var inputType = "{\n    __headers?: {[key: string]: string};\n    __retry?: boolean;\n    __alias?: string;\n    ".concat(argsType ? "__args".concat(argsType.optional ? "?" : "", ": ").concat(argsType.alias) : "", "\n  }").concat(selectionType ? " & ".concat(selectionType) : "");
+    var inputType = "{\n    __headers?: {[key: string]: string};\n    __retry?: boolean;\n    __alias?: string;\n    __url?: string;\n    ".concat(argsType ? "__args".concat(argsType.optional ? "?" : "", ": ").concat(argsType.alias) : "", "\n  }").concat(selectionType ? " & ".concat(selectionType) : "");
     var outputType = gqlTypeToTypescript(endpoint.type, {
         required: true
     });
@@ -773,9 +774,12 @@ function generateClientCode(types, options) {
     var clientCacheFileName = "gql-ts-client__client__".concat(typesHash, "__").concat(package_default.version, ".json");
     var clientCacheFilePath = import_path.default.resolve(tempDir, clientCacheFileName);
     if (!options.skipCache && fs.existsSync(clientCacheFilePath)) {
-        return JSON.parse(fs.readFileSync(clientCacheFilePath, {
+        var output2 = JSON.parse(fs.readFileSync(clientCacheFilePath, {
             encoding: "utf8"
         }));
+        if (output2.js && output2.mjs && output2.typings) {
+            return output2;
+        }
     }
     var queries = ((_types_find = types.find(function(it) {
         return it.name === "Query";
@@ -848,6 +852,10 @@ function generateClientCode(types, options) {
             format: "cjs",
             loader: "js"
         }).code,
+        mjs: esbuild.transformSync(jsCode, {
+            format: "esm",
+            loader: "js"
+        }).code,
         typings: prettier.format(typingsCode, {
             semi: false,
             parser: "typescript"
@@ -866,7 +874,7 @@ function _fetchIntrospection() {
             switch(_state.label){
                 case 0:
                     endpoint = param.endpoint, headers = param.headers;
-                    introspectionCacheFileName = "gql-ts-client__introspection__".concat((0, import_lodash.kebabCase)(endpoint), ".json");
+                    introspectionCacheFileName = "gql-ts-client__introspection__".concat((0, import_kebabCase.default)(endpoint), ".json");
                     introspectionCacheFilePath = import_path.default.resolve(tempDir, introspectionCacheFileName);
                     loadedFromCache = false;
                     return [
@@ -876,20 +884,21 @@ function _fetchIntrospection() {
                         }, {
                             headers: _objectSpread({
                                 "Content-Type": "application/json"
-                            }, headers)
-                        }).catch(function() {
-                            var errorMessage = "The GraphQL introspection request failed (".concat(endpoint, ")");
+                            }, headers),
+                            timeout: 5e3
+                        }).catch(function(e) {
                             if (fs.existsSync(introspectionCacheFilePath)) {
                                 var cachedSchema = JSON.parse(fs.readFileSync(introspectionCacheFilePath, {
                                     encoding: "utf8"
                                 }));
                                 loadedFromCache = true;
-                                console.warn("Successfully restored from local cache.");
+                                console.warn("Successfully restored (".concat(endpoint, ") from local cache."));
                                 return {
                                     data: cachedSchema
                                 };
                             } else {
-                                return Promise.reject(errorMessage);
+                                console.error(e);
+                                return Promise.reject("The GraphQL introspection request failed (".concat(endpoint, ")"));
                             }
                         })
                     ];
@@ -915,7 +924,7 @@ function generateClient(introspectionTypes, _param) {
     var output = _param.output, restOptions = _objectWithoutProperties(_param, [
         "output"
     ]);
-    var _generateClientCode = generateClientCode(introspectionTypes, restOptions), js = _generateClientCode.js, typings = _generateClientCode.typings;
+    var _generateClientCode = generateClientCode(introspectionTypes, restOptions), js = _generateClientCode.js, mjs = _generateClientCode.mjs, typings = _generateClientCode.typings;
     if (output && typeof output === "string") {
         var outputDir = import_path.default.dirname(output);
         if (!fs.existsSync(outputDir)) {
@@ -929,9 +938,13 @@ function generateClient(introspectionTypes, _param) {
         fs.writeFileSync(output.replace(/(\.(ts|js))?$/, ".js"), js, {
             encoding: "utf8"
         });
+        fs.writeFileSync(output.replace(/(\.(ts|js))?$/, ".mjs"), mjs, {
+            encoding: "utf8"
+        });
     }
     return {
         js: js,
+        mjs: mjs,
         typings: typings
     };
 }
@@ -972,11 +985,15 @@ function _generateTypescriptClient() {
     return _generateTypescriptClient.apply(this, arguments);
 }
 function generateTypescriptClientFromSDL(SDL, options) {
-    var _data;
+    var _introspectionResult_data;
     var _options_clientName;
     console.log("Generating TypeScript client from SDL (name: ".concat((_options_clientName = options.clientName) !== null && _options_clientName !== void 0 ? _options_clientName : "n/a", ")"));
     var graphqlSchemaObj = (0, import_graphql.buildSchema)(SDL);
-    var introspectionTypes = (_data = (0, import_graphql.graphqlSync)(graphqlSchemaObj, new import_graphql.Source((0, import_graphql.getIntrospectionQuery)())).data) === null || _data === void 0 ? void 0 : _data.__schema.types;
+    var introspectionResult = (0, import_graphql.graphqlSync)({
+        schema: graphqlSchemaObj,
+        source: (0, import_graphql.getIntrospectionQuery)()
+    });
+    var introspectionTypes = (_introspectionResult_data = introspectionResult.data) === null || _introspectionResult_data === void 0 ? void 0 : _introspectionResult_data.__schema.types;
     return generateClient(introspectionTypes, options);
 }
 // src/types.ts