@avantstay/graphql-ts-client 10.7.0 → 10.9.0

package/dist/index.mjs

@@ -0,0 +1,527 @@
+import {
+  GraphQLClientError
+} from "./chunk-I4QOADOI.mjs";
+
+// src/generateTypescriptClient.ts
+import axios from "axios";
+import axiosRetry from "axios-retry";
+import Case from "case";
+import * as esbuild from "esbuild";
+import * as fs from "fs";
+import {
+  buildSchema,
+  getIntrospectionQuery,
+  graphqlSync,
+  Source
+} from "graphql";
+import kebabCase from "lodash/kebabCase";
+import orderBy from "lodash/orderBy";
+import set from "lodash/set";
+import md5 from "md5";
+import os from "os";
+import path from "path";
+import * as prettier from "prettier";
+
+// package.json
+var package_default = {
+  name: "@avantstay/graphql-ts-client",
+  version: "10.9.0",
+  description: "GraphQL Typescript Client Generator",
+  homepage: "https://github.com/avantstay/graphql-ts-client",
+  bugs: {
+    url: "https://github.com/avantstay/graphql-ts-client/issues"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/avantstay/graphql-ts-client.git"
+  },
+  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"
+    },
+    "./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: "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",
+    lodash: "^4.17.21",
+    md5: "^2.3.0",
+    moize: "^6.1.0",
+    prettier: "^2.5.1",
+    "temp-dir": "^3.0.0",
+    "ts-essentials": "^8.1.0"
+  },
+  devDependencies: {
+    "@babel/preset-env": "^7.20.2",
+    "@babel/preset-typescript": "^7.18.6",
+    "@jest/globals": "^29.3.1",
+    "@size-limit/preset-small-lib": "^5.0.4",
+    "@swc/core": "^1.3.22",
+    "@types/graphql": "^14.5.0",
+    "@types/jest": "^29.2.4",
+    "@types/lodash": "^4.14.177",
+    "@types/node": "^16.11.12",
+    "@types/prettier": "^2.4.2",
+    "apollo-server": "^3.11.1",
+    concurrently: "^7.6.0",
+    "cross-env": "^7.0.3",
+    jest: "^29.3.1",
+    "ts-jest": "^29.0.3",
+    "ts-node": "^10.9.1",
+    tslib: "^2.3.1",
+    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(os.tmpdir());
+var graphqlTsClientPath = process.env.GQL_CLIENT_DIST_PATH || "@avantstay/graphql-ts-client/dist";
+function gqlScalarToTypescript(gqlType) {
+  if (/(int|long|double|decimal|float)/i.test(gqlType))
+    return "number";
+  if (/boolean/i.test(gqlType))
+    return "boolean";
+  if (/String/i.test(gqlType))
+    return "string";
+  return gqlType;
+}
+function gqlTypeToTypescript(gqlType, { required = false, isInput = false, selection = false } = {}) {
+  if (!gqlType)
+    return "";
+  const maybeWrapped = (it) => required || selection ? it : `Maybe<${it}>`;
+  if (typeof gqlType === "string") {
+    return maybeWrapped(gqlType);
+  }
+  if (gqlType.kind.endsWith("OBJECT")) {
+    return maybeWrapped(gqlType.name + (selection ? "Selection" : ""));
+  }
+  if (gqlType.kind === "NON_NULL") {
+    return `${gqlTypeToTypescript(gqlType.ofType, {
+      isInput,
+      required: true,
+      selection
+    })}`;
+  }
+  if (gqlType.kind === "LIST") {
+    return maybeWrapped(
+      `${gqlTypeToTypescript(gqlType.ofType, {
+        isInput,
+        required: true,
+        selection
+      })}${selection ? "" : "[]"}`
+    );
+  }
+  if (selection) {
+    return "";
+  }
+  if (gqlType.kind === "ENUM" && gqlType.name) {
+    return maybeWrapped(gqlType.name);
+  }
+  if (gqlType.kind === "SCALAR") {
+    return maybeWrapped(gqlScalarToTypescript(gqlType.name));
+  }
+  return "";
+}
+function gqlFieldToTypescript(field, { isInput, selection, defaultValue }) {
+  let fieldTypeDefinition = gqlTypeToTypescript(field.type, {
+    isInput,
+    selection
+  });
+  fieldTypeDefinition = `${fieldTypeDefinition}`;
+  if (selection && field.args && field.args.length) {
+    let fieldsOnArgs = field.args.map(
+      (arg) => gqlFieldToTypescript(arg, {
+        defaultValue: arg.defaultValue,
+        isInput: true,
+        selection: false
+      })
+    );
+    fieldTypeDefinition = `{ __headers?: {[key: string]: string}; __retry?: boolean; __alias?: string; __url?: string; __args${fieldsOnArgs.every((arg) => arg.isOptional) ? "?" : ""}: { ${fieldsOnArgs.map((arg) => arg.code).join(", ")} }}${fieldTypeDefinition ? ` & ${fieldTypeDefinition}` : ""}`;
+  }
+  const isOptional = defaultValue || selection || fieldTypeDefinition.startsWith("Maybe");
+  const rawType = fieldTypeDefinition || selection && "boolean";
+  const wrappedType = isOptional ? rawType.replace(/Maybe<(.+?)>/, "$1") : rawType;
+  return {
+    isOptional,
+    code: `${field.name}${isOptional ? "?:" : ":"} ${wrappedType}`
+  };
+}
+function getArgsType(endpoint) {
+  const fieldsOnArgs = endpoint.args.map(
+    (arg) => gqlFieldToTypescript(arg, {
+      defaultValue: arg.defaultValue,
+      isInput: true,
+      selection: false
+    })
+  );
+  const argsType = `{ ${fieldsOnArgs.map((arg) => arg.code).join(", ")} }`;
+  const argsFullyOptional = fieldsOnArgs.every((arg) => arg.isOptional);
+  return { alias: Case.pascal(`${endpoint.name}Args`), type: argsType, optional: argsFullyOptional };
+}
+function gqlEndpointToCode(kind, endpoint, codeOutputType) {
+  const selectionType = gqlTypeToTypescript(endpoint.type, {
+    isInput: false,
+    selection: true
+  });
+  const argsType = endpoint.args && endpoint.args.length ? getArgsType(endpoint) : null;
+  const inputType = `{
+    __headers?: {[key: string]: string};
+    __retry?: boolean;
+    __alias?: string;
+    __url?: string;
+    ${argsType ? `__args${argsType.optional ? "?" : ""}: ${argsType.alias}` : ""}
+  }${selectionType ? ` & ${selectionType}` : ""}`;
+  const outputType = gqlTypeToTypescript(endpoint.type, { required: true });
+  return codeOutputType === "ts" ? `${endpoint.name}: Endpoint<${inputType}, ${outputType}, AllEnums>` : `${endpoint.name}: apiEndpoint('${kind}', '${endpoint.name}')`;
+}
+function gqlSchemaToCode(gqlType, { selection = false, outputType }) {
+  const rawKind = gqlType.kind || gqlType.type;
+  if (rawKind === "SCALAR") {
+    return outputType === "ts" ? `export declare type ${gqlType.name} = ${/date/i.test(gqlType.name) ? "IDate" : "string"}` : "";
+  }
+  if (rawKind === "ENUM")
+    return outputType === "ts" ? `
+      export declare enum ${gqlType.name} {
+        ${orderBy(gqlType.enumValues, "name").map((_) => `${Case.camel(_.name)} = '${_.name}'`).join(",\n  ")}
+      }` : `export const ${gqlType.name} = {${orderBy(gqlType.enumValues, "name").map((_) => `${Case.camel(_.name)}: '${_.name}'`).join(",\n  ")}}`;
+  const fields = gqlType.fields && gqlType.fields || gqlType.inputFields && gqlType.inputFields || [];
+  return outputType === "ts" ? `
+    export interface ${gqlType.name}${selection ? "Selection" : ""} {
+      ${fields.map(
+    (_) => gqlFieldToTypescript(_, {
+      isInput: gqlType.kind === "INPUT_OBJECT",
+      selection
+    }).code
+  ).join(",\n  ")}
+    }` : "";
+}
+function getGraphQLInputType(type) {
+  switch (type.kind) {
+    case "NON_NULL":
+      return `${getGraphQLInputType(type.ofType)}!`;
+    case "SCALAR":
+    case "INPUT_OBJECT":
+    case "ENUM":
+      return type.name;
+    case "LIST":
+      return `[${getGraphQLInputType(type.ofType)}]`;
+    default:
+      return "";
+  }
+}
+function getGraphQLOutputType(type) {
+  switch (type.kind) {
+    case "LIST":
+      return `${getGraphQLOutputType(type.ofType)}[]`;
+    case "NON_NULL":
+      return getGraphQLOutputType(type.ofType);
+    case "OBJECT":
+      return type.name;
+    default:
+      return "";
+  }
+}
+function getTypesTreeCode(types) {
+  const typesTree = {};
+  types.forEach(
+    (type) => type.fields.filter((_) => _.args && _.args.length).forEach(
+      (_) => _.args.forEach((a) => {
+        let inputType = getGraphQLInputType(a.type);
+        if (inputType) {
+          set(typesTree, `${type.name}.${_.name}.__args.${a.name}`, inputType);
+        }
+      })
+    )
+  );
+  types.forEach(
+    (t) => t.fields.forEach((f) => {
+      let outputType = getGraphQLOutputType(f.type);
+      if (outputType) {
+        set(typesTree, `${t.name}.${f.name}.__shape`, outputType);
+      }
+    })
+  );
+  return `
+    const typesTree = {
+      ${Object.entries(typesTree).map(([key, value]) => {
+    let entryCode = Object.entries(value).map(([k, v]) => {
+      const cleanShapeType = v.__shape && v.__shape.replace(/[\[\]!?]/g, "");
+      const fieldsCode = v.__shape && typesTree.hasOwnProperty(cleanShapeType) ? `__fields: typesTree.${cleanShapeType},` : "";
+      const argsCode = v.__args ? `__args: {
+                      ${Object.entries(v.__args).map(([k2, v2]) => `${k2}: '${v2}'`).join(",\n")}
+                    }` : "";
+      return fieldsCode || argsCode ? `get ${k}() {
+                  return {
+                    ${fieldsCode}
+                    ${argsCode}
+                  }
+                }` : `${k}: {}`;
+    }).filter(Boolean).join(",\n").trim();
+    return entryCode && `
+              ${key}: { 
+                ${entryCode} 
+              }`;
+  }).filter(Boolean).join(",\n")}
+    }
+  `;
+}
+function generateClientCode(types, options) {
+  const typesHash = md5(`${JSON.stringify(options)}__${JSON.stringify(types)}`);
+  const clientCacheFileName = `gql-ts-client__client__${typesHash}__${package_default.version}.json`;
+  const clientCacheFilePath = path.resolve(tempDir, clientCacheFileName);
+  if (!options.skipCache && fs.existsSync(clientCacheFilePath)) {
+    const output2 = JSON.parse(fs.readFileSync(clientCacheFilePath, { encoding: "utf8" }));
+    if (output2.js && output2.mjs && output2.typings) {
+      return output2;
+    }
+  }
+  const queries = types.find((it) => it.name === "Query")?.fields || [];
+  const mutations = types.find((it) => it.name === "Mutation")?.fields || [];
+  const enums = types.filter((it) => it.kind === "ENUM" && !it.name.startsWith("__"));
+  const scalars = types.filter(
+    (it) => it.kind === "SCALAR" && !/decimal|int|float|string|long|boolean/i.test(it.name)
+  );
+  const objectTypes = types.filter((it) => ["OBJECT", "INPUT_OBJECT"].includes(it.kind) && !it.name.startsWith("__"));
+  const forInputExtraction = types.filter(
+    (it) => !it.name.startsWith("__") && ["OBJECT"].includes(it.kind)
+  );
+  const clientName = options.clientName || "client";
+  const jsCode = `
+    // noinspection TypeScriptUnresolvedVariable, ES6UnusedImports, JSUnusedLocalSymbols
+    import { getApiEndpointCreator } from '${graphqlTsClientPath}/endpoint'
+    
+    ${options.formatGraphQL || options.verbose ? `
+      import { format as formatCode } from "prettier/standalone"
+      import parserGraphql from "prettier/parser-graphql"
+      
+      const formatGraphQL = (query) => formatCode(query, {parser: 'graphql', plugins: [parserGraphql]})` : `
+      const formatGraphQL = (query) => query`}
+    
+    // Enums
+    ${enums.map((it) => gqlSchemaToCode(it, { selection: false, outputType: "js" })).join("\n")}
+
+    // Schema Resolution Tree
+    ${getTypesTreeCode(forInputExtraction)}
+
+    let verbose = ${Boolean(options.verbose)}
+    let headers = {}
+    let url = '${options.endpoint}'
+    let retryConfig = {
+      max: 0,
+      before: undefined,
+      waitBeforeRetry: 0
+    }
+    let responseListeners = []
+    let errorsParser = ${options.errorsParser}
+    // noinspection JSUnusedLocalSymbols
+    let apiEndpoint = getApiEndpointCreator({
+      getClient: () => ({ url, headers, retryConfig }),
+      responseListeners,
+      maxAge: 30000,
+      verbose,
+      typesTree,
+      formatGraphQL,
+      errorsParser
+    })
+
+    export const ${clientName} = {
+      addResponseListener: (listener) => responseListeners.push(
+        listener),
+      setHeader: (key, value) => {
+        headers[key] = value
+      },
+      setHeaders: (newHeaders) => {
+        headers = newHeaders
+      },
+      setRetryConfig: (options) => {
+        if (!Number.isInteger(options.max) || options.max < 0) {
+          throw new Error('retryOptions.max should be a non-negative integer')
+        }
+        
+        retryConfig = { 
+          max: options.max,
+          waitBeforeRetry: options.waitBeforeRetry,
+          before: options.before 
+        }
+      },
+      setUrl: (_url) => url = _url,
+      queries: {
+        ${queries.map((query) => gqlEndpointToCode("query", query, "js")).join(",\n")}
+      },
+      mutations: {
+        ${mutations.map((mutation) => gqlEndpointToCode("mutation", mutation, "js")).join(",\n")}
+      }
+    }
+
+    export default ${clientName}`;
+  const typingsCode = `
+    // noinspection TypeScriptUnresolvedVariable, ES6UnusedImports, JSUnusedLocalSymbols, TypeScriptCheckImport
+    import { DeepRequired } from 'ts-essentials'
+    import { Maybe, IResponseListener, Endpoint } from '${graphqlTsClientPath}'
+
+    // Scalars
+    export type IDate = string | Date
+    ${scalars.map((it) => gqlSchemaToCode(it, { selection: false, outputType: "ts" })).join("\n")}
+
+    // Enums
+    ${enums.map((it) => gqlSchemaToCode(it, { selection: false, outputType: "ts" })).join("\n")}
+    
+    type AllEnums = ${enums.length ? enums.map((it) => it.name).join(" | ") : "never"}
+    
+    // Args
+    ${[...queries, ...mutations].map((query) => {
+    const argsType = getArgsType(query);
+    return `export interface ${argsType.alias} ${argsType.type}`;
+  }).join("\n")}
+
+    // Input/Output Types
+    ${objectTypes.map(
+    (it) => `
+    /**
+     * @deprecated Avoid directly using this interface. Instead, create a type alias based on the query/mutation return type.
+     */
+    ${gqlSchemaToCode(it, { selection: false, outputType: "ts" })}`
+  ).join("\n")}
+
+    // Selection Types
+    ${objectTypes.filter((it) => it.name !== "Query").map((it) => gqlSchemaToCode(it, { selection: true, outputType: "ts" })).join("\n")}
+    
+    export declare const ${clientName}: {
+      addResponseListener: (listener: IResponseListener) => void
+      setHeader: (key: string, value: string) => void
+      setHeaders: (newHeaders: { [k: string]: string }) => void,
+      setUrl: (url: string) => void,
+      setRetryConfig: (options: { max: number, waitBeforeRetry?: number, before?: IResponseListener }) => void
+      queries: {
+        ${queries.map((q) => gqlEndpointToCode("query", q, "ts")).join(",\n")}
+      },
+      mutations: {
+        ${mutations.map((q) => gqlEndpointToCode("mutation", q, "ts")).join(",\n")}
+      }
+    }
+
+    export default ${clientName}`;
+  const output = {
+    js: esbuild.transformSync(jsCode, { format: "cjs", loader: "js" }).code,
+    mjs: esbuild.transformSync(jsCode, { format: "esm", loader: "js" }).code,
+    typings: prettier.format(typingsCode, { semi: false, parser: "typescript" })
+  };
+  fs.writeFileSync(clientCacheFilePath, JSON.stringify(output));
+  return output;
+}
+async function fetchIntrospection({ endpoint, headers }) {
+  const introspectionCacheFileName = `gql-ts-client__introspection__${kebabCase(endpoint)}.json`;
+  const introspectionCacheFilePath = path.resolve(tempDir, introspectionCacheFileName);
+  let loadedFromCache = false;
+  let types;
+  const { data } = await axios.post(
+    endpoint,
+    { query: getIntrospectionQuery() },
+    {
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      }
+    }
+  ).catch((e) => {
+    const errorMessage = `The GraphQL introspection request failed (${endpoint})`;
+    if (fs.existsSync(introspectionCacheFilePath)) {
+      const cachedSchema = JSON.parse(fs.readFileSync(introspectionCacheFilePath, { encoding: "utf8" }));
+      loadedFromCache = true;
+      console.warn(`Successfully restored from local cache.`);
+      return { data: cachedSchema };
+    } else {
+      console.error(e);
+      return Promise.reject(errorMessage);
+    }
+  });
+  types = data.data.__schema.types;
+  if (!loadedFromCache) {
+    console.log(`Successfully loaded GraphQL introspection from ${endpoint}`);
+    fs.writeFileSync(introspectionCacheFilePath, JSON.stringify(data), {
+      encoding: "utf8"
+    });
+  }
+  return types;
+}
+function generateClient(introspectionTypes, { output, ...restOptions }) {
+  const { js, mjs, typings } = generateClientCode(introspectionTypes, restOptions);
+  if (output && typeof output === "string") {
+    const outputDir = path.dirname(output);
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+    fs.writeFileSync(output.replace(/(\.(ts|js))?$/, ".d.ts"), typings, { encoding: "utf8" });
+    fs.writeFileSync(output.replace(/(\.(ts|js))?$/, ".js"), js, { encoding: "utf8" });
+    fs.writeFileSync(output.replace(/(\.(ts|js))?$/, ".mjs"), mjs, { encoding: "utf8" });
+  }
+  return { js, mjs, typings };
+}
+async function generateTypescriptClient({
+  introspectionEndpoint,
+  ...options
+}) {
+  console.log(`Generating TypeScript client (name: ${options.clientName ?? "n/a"})`);
+  axiosRetry(axios, { retries: 5, retryDelay: (retryCount) => 1e3 * 2 ** retryCount });
+  const introspectionTypes = await fetchIntrospection({
+    ...options,
+    endpoint: introspectionEndpoint || options.endpoint
+  });
+  return generateClient(introspectionTypes, options);
+}
+function generateTypescriptClientFromSDL(SDL, options) {
+  console.log(`Generating TypeScript client from SDL (name: ${options.clientName ?? "n/a"})`);
+  const graphqlSchemaObj = buildSchema(SDL);
+  const introspectionTypes = graphqlSync(graphqlSchemaObj, new Source(getIntrospectionQuery())).data?.__schema.types;
+  return generateClient(introspectionTypes, options);
+}
+export {
+  GraphQLClientError,
+  generateTypescriptClient,
+  generateTypescriptClientFromSDL
+};

package/dist/types-23d2d6aa.d.ts

@@ -0,0 +1,75 @@
+type Maybe<T> = null | undefined | T;
+type Defined<T> = Exclude<T, undefined>;
+type ResponseData = {
+    data: any;
+    warnings: any;
+    headers: any;
+    status?: number;
+    errors: {
+        message: string;
+    }[];
+};
+type ResponseListenerInfo = {
+    queryName: string;
+    query: string;
+    variables: any;
+    response: ResponseData;
+};
+type IResponseListener = (info: ResponseListenerInfo) => void | Promise<void>;
+type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
+type Primitive = Date | string | number | boolean | null | undefined;
+type Projection<Selection, Base, E = never> = Base extends Array<any> ? ArrayElement<Base> extends Primitive | E ? ArrayElement<Base>[] : Projection<Defined<Selection>, ArrayElement<Base>, E>[] : Base extends Primitive | E ? Selection extends undefined ? Base | undefined : Base : {
+    [k in keyof Selection & keyof Base]: Selection[k] extends boolean ? Base[k] : Base[k] extends Array<infer A> ? Projection<Defined<Selection[k]>, A, E>[] : Projection<Defined<Selection[k]>, Base[k], E>;
+};
+type Unpacked<T> = T extends (infer U)[] ? U : T extends (...args: any[]) => infer U ? U : T extends Promise<infer U> ? U : T;
+type Replacement<M extends [any, any], T> = M extends any ? ([T] extends [M[0]] ? M[1] : never) : never;
+type DeepReplace<T, Ignore, M extends [any, any]> = {
+    [P in keyof T]: T[P] extends M[0] ? T[P] extends Ignore ? T[P] extends object ? DeepReplace<T[P], Ignore, M> : T[P] : Replacement<M, T[P]> : T[P] extends object ? DeepReplace<T[P], Ignore, M> : T[P];
+};
+type RawEndpoint<I, O, E> = <S extends I>(jsonQuery?: S) => Promise<{
+    data: Projection<S, O, E>;
+    errors: any[];
+    warnings: any[];
+    headers: any;
+    status: any;
+}>;
+type JsonOutput<O, ToBeIgnored> = DeepReplace<O, ToBeIgnored, [string | Date, string]>;
+type Endpoint<I, O, E> = (<S extends I>(jsonQuery?: S) => Promise<Projection<S, JsonOutput<O, E>, E>>) & {
+    memo: <S extends I>(jsonQuery?: S) => Promise<Projection<S, JsonOutput<O, E>, E>>;
+    memoRaw: RawEndpoint<I, JsonOutput<O, E>, E>;
+    raw: RawEndpoint<I, JsonOutput<O, E>, E>;
+};
+type ClientConfig = {
+    url: string;
+    headers: {
+        [key: string]: string;
+    };
+    retryConfig: {
+        max: number;
+        waitBeforeRetry?: number;
+        before: IResponseListener;
+    };
+};
+type LogInfo = {
+    query: string;
+    variables: any;
+    formatGraphQL: any;
+    kind: string;
+    queryName: string;
+    response?: any;
+    error?: Error;
+    duration: number;
+};
+type TypescriptClientOutput = {
+    js: string;
+    mjs: string;
+    typings: string;
+};
+declare class GraphQLClientError extends Error {
+    responseData: ResponseData;
+    constructor(responseData: ResponseData);
+    get message(): string;
+    get response(): ResponseData;
+}
+
+export { ClientConfig as C, Defined as D, Endpoint as E, GraphQLClientError as G, IResponseListener as I, JsonOutput as J, LogInfo as L, Maybe as M, Projection as P, ResponseData as R, TypescriptClientOutput as T, Unpacked as U, ResponseListenerInfo as a, Replacement as b, DeepReplace as c, RawEndpoint as d };

package/dist/types-4ada662b.d.ts

@@ -0,0 +1,70 @@
+type Maybe<T> = null | undefined | T;
+type Defined<T> = Exclude<T, undefined>;
+type ResponseData = {
+    data: any;
+    warnings: any;
+    headers: any;
+    status?: number;
+    errors: {
+        message: string;
+    }[];
+};
+type ResponseListenerInfo = {
+    queryName: string;
+    query: string;
+    variables: any;
+    response: ResponseData;
+};
+type IResponseListener = (info: ResponseListenerInfo) => void | Promise<void>;
+type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
+type Primitive = Date | string | number | boolean | null | undefined;
+type Projection<Selection, Base, E = never> = Base extends Array<any> ? ArrayElement<Base> extends Primitive | E ? ArrayElement<Base>[] : Projection<Defined<Selection>, ArrayElement<Base>, E>[] : Base extends Primitive | E ? Selection extends undefined ? Base | undefined : Base : {
+    [k in keyof Selection & keyof Base]: Selection[k] extends boolean ? Base[k] : Base[k] extends Array<infer A> ? Projection<Defined<Selection[k]>, A, E>[] : Projection<Defined<Selection[k]>, Base[k], E>;
+};
+type Unpacked<T> = T extends (infer U)[] ? U : T extends (...args: any[]) => infer U ? U : T extends Promise<infer U> ? U : T;
+type Replacement<M extends [any, any], T> = M extends any ? ([T] extends [M[0]] ? M[1] : never) : never;
+type DeepReplace<T, Ignore, M extends [any, any]> = {
+    [P in keyof T]: T[P] extends M[0] ? T[P] extends Ignore ? T[P] extends object ? DeepReplace<T[P], Ignore, M> : T[P] : Replacement<M, T[P]> : T[P] extends object ? DeepReplace<T[P], Ignore, M> : T[P];
+};
+type RawEndpoint<I, O, E> = <S extends I>(jsonQuery?: S) => Promise<{
+    data: Projection<S, O, E>;
+    errors: any[];
+    warnings: any[];
+    headers: any;
+    status: any;
+}>;
+type JsonOutput<O, ToBeIgnored> = DeepReplace<O, ToBeIgnored, [string | Date, string]>;
+type Endpoint<I, O, E> = (<S extends I>(jsonQuery?: S) => Promise<Projection<S, JsonOutput<O, E>, E>>) & {
+    memo: <S extends I>(jsonQuery?: S) => Promise<Projection<S, JsonOutput<O, E>, E>>;
+    memoRaw: RawEndpoint<I, JsonOutput<O, E>, E>;
+    raw: RawEndpoint<I, JsonOutput<O, E>, E>;
+};
+type ClientConfig = {
+    url: string;
+    headers: {
+        [key: string]: string;
+    };
+    retryConfig: {
+        max: number;
+        waitBeforeRetry?: number;
+        before: IResponseListener;
+    };
+};
+type LogInfo = {
+    query: string;
+    variables: any;
+    formatGraphQL: any;
+    kind: string;
+    queryName: string;
+    response?: any;
+    error?: Error;
+    duration: number;
+};
+declare class GraphQLClientError extends Error {
+    responseData: ResponseData;
+    constructor(responseData: ResponseData);
+    get message(): string;
+    get response(): ResponseData;
+}
+
+export { ClientConfig as C, Defined as D, Endpoint as E, GraphQLClientError as G, IResponseListener as I, JsonOutput as J, LogInfo as L, Maybe as M, Projection as P, ResponseData as R, Unpacked as U, ResponseListenerInfo as a, Replacement as b, DeepReplace as c, RawEndpoint as d };