@avantstay/graphql-ts-client 11.0.0 → 12.0.0

package/dist/index.mjs

@@ -0,0 +1,530 @@
+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
+} 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: "12.0.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: "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: "^16.13.2",
+    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
+      },
+      timeout: 5e3
+    }
+  ).catch((e) => {
+    if (fs.existsSync(introspectionCacheFilePath)) {
+      const cachedSchema = JSON.parse(fs.readFileSync(introspectionCacheFilePath, { encoding: "utf8" }));
+      loadedFromCache = true;
+      console.warn(`Successfully restored (${endpoint}) from local cache.`);
+      return { data: cachedSchema };
+    } else {
+      console.error(e);
+      return Promise.reject(`The GraphQL introspection request failed (${endpoint})`);
+    }
+  });
+  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 introspectionResult = graphqlSync({
+    schema: graphqlSchemaObj,
+    source: getIntrospectionQuery()
+  });
+  const introspectionTypes = introspectionResult.data?.__schema.types;
+  return generateClient(introspectionTypes, options);
+}
+export {
+  GraphQLClientError,
+  generateTypescriptClient,
+  generateTypescriptClientFromSDL
+};

package/dist/{types-4ada662b.d.ts → types-23d2d6aa.d.ts}

@@ -60,6 +60,11 @@ type LogInfo = {
     error?: Error;
     duration: number;
 };
+type TypescriptClientOutput = {
+    js: string;
+    mjs: string;
+    typings: string;
+};
 declare class GraphQLClientError extends Error {
     responseData: ResponseData;
     constructor(responseData: ResponseData);
@@ -67,4 +72,4 @@ declare class GraphQLClientError extends Error {
     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 };
+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/package.json

@@ -1,64 +1,51 @@
 {
   "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",
@@ -87,7 +74,21 @@
     "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"
+    }
+  ]
 }