@avantstay/graphql-ts-client 11.0.0 → 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.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

@@ -487,65 +487,52 @@ var prettier = __toESM(require("prettier"));
 // package.json
 var package_default = {
     name: "@avantstay/graphql-ts-client",
-    version: "11.0.0",
+    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());
@@ -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"
@@ -876,21 +884,21 @@ function _fetchIntrospection() {
                         }, {
                             headers: _objectSpread({
                                 "Content-Type": "application/json"
-                            }, headers)
+                            }, headers),
+                            timeout: 5e3
                         }).catch(function(e) {
-                            var errorMessage = "The GraphQL introspection request failed (".concat(endpoint, ")");
                             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 {
                                 console.error(e);
-                                return Promise.reject(errorMessage);
+                                return Promise.reject("The GraphQL introspection request failed (".concat(endpoint, ")"));
                             }
                         })
                     ];
@@ -916,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)) {
@@ -930,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
     };
 }
@@ -973,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