@avantstay/graphql-ts-client 11.0.0 → 12.0.1

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-2VJ7JZPA.mjs

@@ -0,0 +1,18 @@
+// 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 {
+  GraphQLClientError
+};

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

@@ -591,17 +591,14 @@ function _graphqlRequest() {
     return _graphqlRequest.apply(this, arguments);
 }
 // src/jsonToGraphQLQuery.ts
-var import_omit = __toESM(require("lodash/omit"));
+var import_lodash = require("lodash");
 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(param) {
     var kind = param.kind, queryName = param.queryName, _param_jsonQuery = param.jsonQuery, jsonQuery = _param_jsonQuery === void 0 ? {} : _param_jsonQuery, typesTree = param.typesTree;
     var variablesData = {};
     var alias = jsonQuery.__alias;
-    var newJsonQuery = cloneDeep((0, import_omit.default)(jsonQuery, [
+    var newJsonQuery = (0, import_lodash.cloneDeep)((0, import_lodash.omit)(jsonQuery, [
         "__alias",
         "__headers",
         "__url"
@@ -621,12 +618,12 @@ function jsonToGraphQLQuery(param) {
         });
         return variablesObj;
     }, {});
-    var variablesQuery = Object.keys(variableItems).length ? "(".concat(entries(variableItems).map(function(param) {
+    var variablesQuery = Object.keys(variableItems).length ? "(".concat((0, import_lodash.toPairs)(variableItems).map(function(param) {
         var _param = _slicedToArray(param, 2), queryName2 = _param[0], type = _param[1].type;
         return "$".concat(queryName2, ": ").concat(type);
     }).join(", "), ")") : "";
     var query = "".concat(kind, " ").concat(alias || queryName).concat(variablesQuery, " { ").concat(alias ? "".concat(alias, ":") : "").concat(queryName).concat(toGraphql(newJsonQuery), " }");
-    var variables = fromEntries(entries(variableItems).map(function(param) {
+    var variables = (0, import_lodash.fromPairs)((0, import_lodash.toPairs)(variableItems).map(function(param) {
         var _param = _slicedToArray(param, 2), k = _param[0], v = _param[1];
         return [
             k,
@@ -673,14 +670,14 @@ function extractVariables(param) {
     });
 }
 function toGraphql(jsonQuery) {
-    var fields = entries(jsonQuery).filter(function(param) {
+    var fields = (0, import_lodash.toPairs)(jsonQuery).filter(function(param) {
         var _param = _slicedToArray(param, 2), k = _param[0], v = _param[1];
         return k !== "__args" && v !== false && v !== void 0;
     }).map(function(param) {
         var _param = _slicedToArray(param, 2), k = _param[0], v = _param[1];
         return typeof v === "object" ? "".concat(k).concat(toGraphql(v)) : k;
     }).join(" ");
-    var validArgs = jsonQuery.__args ? entries(jsonQuery.__args).filter(function(param) {
+    var validArgs = jsonQuery.__args ? (0, import_lodash.toPairs)(jsonQuery.__args).filter(function(param) {
         var _param = _slicedToArray(param, 2), _ = _param[0], v = _param[1];
         return v !== void 0;
     }) : [];

package/dist/endpoint.mjs

@@ -0,0 +1,271 @@
+import {
+  GraphQLClientError
+} from "./chunk-2VJ7JZPA.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 { cloneDeep, fromPairs as fromEntries, omit, toPairs as entries } from "lodash";
+var VAR_PREFIX = "@@VAR@@";
+var VAR_PREFIX_LENGTH = VAR_PREFIX.length;
+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 };