@avantstay/graphql-ts-client 10.5.0

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

@@ -0,0 +1,69 @@
+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 Projection<Selection, Base, E = never> = Base extends Array<any> ? ArrayElement<Base> extends Date | string | number | boolean | null | undefined | E ? ArrayElement<Base>[] : Projection<Defined<Selection>, ArrayElement<Base>, E>[] : Base extends Date | string | number | boolean | null | 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 };

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@avantstay/graphql-ts-client",
+  "version": "10.5.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"
+  },
+  "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"
+    },
+    {
+      "path": "dist/graphql-ts-client.esm.js",
+      "limit": "10 KB"
+    }
+  ],
+  "dependencies": {
+    "@types/md5": "^2.3.2",
+    "axios": "^1.4.0",
+    "axios-retry": "^3.5.1",
+    "case": "^1.6.3",
+    "esbuild": "^0.18.16",
+    "graphql": "^16.7.1",
+    "lodash": "^4.17.21",
+    "md5": "^2.3.0",
+    "moize": "^6.1.6",
+    "prettier": "^2.8.8",
+    "ts-essentials": "^8.1.0"
+  },
+  "devDependencies": {
+    "@babel/preset-env": "^7.22.9",
+    "@babel/preset-typescript": "^7.22.5",
+    "@jest/globals": "^29.6.1",
+    "@types/graphql": "^14.5.0",
+    "@types/jest": "^29.5.3",
+    "@types/lodash": "^4.14.195",
+    "@types/node": "^20.4.5",
+    "@types/prettier": "^2.7.3",
+    "apollo-server": "^3.12.0",
+    "cross-env": "^7.0.3",
+    "jest": "^29.6.1",
+    "ts-node": "^10.9.1",
+    "tsup": "^7.1.0",
+    "typescript": "^5.1.6",
+    "@swc/core": "^1.3.71"
+  }
+}

package/src/__snapshots__/graphqlRequest.test.ts.snap

@@ -0,0 +1,24 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`GraphQLRequest Should request have proper structure 1`] = `
+Arguments [
+  "https://whatever.com",
+  {
+    "operationName": "sampleQueryName",
+    "query": "sampleQuery",
+    "variables": {
+      "bar": "foo",
+      "foo": "bar",
+    },
+  },
+  {
+    "headers": {
+      "Content-Type": "application/json",
+    },
+    "params": {
+      "_q": "sampleQueryName",
+    },
+    "validateStatus": [Function],
+  },
+]
+`;

package/src/__testClient.d.ts

@@ -0,0 +1,148 @@
+// noinspection TypeScriptUnresolvedVariable, ES6UnusedImports, JSUnusedLocalSymbols, TypeScriptCheckImport
+import { DeepRequired } from "ts-essentials"
+import { Maybe, IResponseListener, Endpoint } from "."
+
+// Scalars
+export type IDate = string | Date
+export declare type ISODate = IDate
+
+// Enums
+
+export declare enum BookType {
+  dolor = "DOLOR",
+  ipsum = "IPSUM",
+  sit = "SIT",
+}
+
+type AllEnums = BookType
+
+// Args
+export interface BooksWithoutParamsArgs {}
+export interface BooksWithOptionalParamsArgs {
+  params?: BookSearchParamsAllOptional
+}
+export interface BooksWithRequiredParamsArgs {
+  params: BookSearchParamsSomeRequired
+}
+export interface FailingQueryArgs {
+  id: string
+}
+
+// Input/Output Types
+
+/**
+ * @deprecated Avoid directly using this interface. Instead, create a type alias based on the query/mutation return type.
+ */
+
+export interface Book {
+  title?: string
+  author?: string
+  type?: BookType
+  dateCreated?: ISODate
+}
+
+/**
+ * @deprecated Avoid directly using this interface. Instead, create a type alias based on the query/mutation return type.
+ */
+
+export interface BookSearchParamsAllOptional {
+  title?: string
+  author?: string
+  createdAfter?: ISODate
+}
+
+/**
+ * @deprecated Avoid directly using this interface. Instead, create a type alias based on the query/mutation return type.
+ */
+
+export interface BookSearchParamsSomeRequired {
+  title: string
+  author?: string
+}
+
+/**
+ * @deprecated Avoid directly using this interface. Instead, create a type alias based on the query/mutation return type.
+ */
+
+export interface Query {
+  booksWithoutParams?: Book[]
+  booksWithOptionalParams?: Book[]
+  booksWithRequiredParams?: Book[]
+  failingQuery?: string
+}
+
+// Selection Types
+
+export interface BookSelection {
+  title?: boolean
+  author?: boolean
+  type?: boolean
+  dateCreated?: boolean
+}
+
+export interface BookSearchParamsAllOptionalSelection {
+  title?: boolean
+  author?: boolean
+  createdAfter?: boolean
+}
+
+export interface BookSearchParamsSomeRequiredSelection {
+  title?: boolean
+  author?: boolean
+}
+
+export declare const myApiClient: {
+  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: {
+    booksWithoutParams: Endpoint<
+      {
+        __headers?: { [key: string]: string }
+        __retry?: boolean
+        __alias?: string
+      } & BookSelection,
+      DeepRequired<Book[]>,
+      AllEnums
+    >
+    booksWithOptionalParams: Endpoint<
+      {
+        __headers?: { [key: string]: string }
+        __retry?: boolean
+        __alias?: string
+        __args?: BooksWithOptionalParamsArgs
+      } & BookSelection,
+      DeepRequired<Book[]>,
+      AllEnums
+    >
+    booksWithRequiredParams: Endpoint<
+      {
+        __headers?: { [key: string]: string }
+        __retry?: boolean
+        __alias?: string
+        __args: BooksWithRequiredParamsArgs
+      } & BookSelection,
+      DeepRequired<Book[]>,
+      AllEnums
+    >
+    failingQuery: Endpoint<
+      {
+        __headers?: { [key: string]: string }
+        __retry?: boolean
+        __alias?: string
+        __args: FailingQueryArgs
+      },
+      string,
+      AllEnums
+    >
+  }
+  mutations: {}
+}
+
+export default myApiClient

package/src/__testClient.js

@@ -0,0 +1,118 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  BookType: () => BookType,
+  default: () => stdin_default,
+  myApiClient: () => myApiClient
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_endpoint = require("./endpoint");
+var import_standalone = require("prettier/standalone");
+var import_parser_graphql = __toESM(require("prettier/parser-graphql"));
+const formatGraphQL = (query) => (0, import_standalone.format)(query, { parser: "graphql", plugins: [import_parser_graphql.default] });
+const BookType = {
+  dolor: "DOLOR",
+  ipsum: "IPSUM",
+  sit: "SIT"
+};
+const typesTree = {
+  Query: {
+    get booksWithOptionalParams() {
+      return {
+        __args: {
+          params: "BookSearchParamsAllOptional!"
+        }
+      };
+    },
+    get booksWithRequiredParams() {
+      return {
+        __args: {
+          params: "BookSearchParamsSomeRequired!"
+        }
+      };
+    },
+    get failingQuery() {
+      return {
+        __args: {
+          id: "String!"
+        }
+      };
+    },
+    booksWithoutParams: {}
+  }
+};
+let verbose = false;
+let headers = {};
+let url = "http://localhost:4123/graphql";
+let retryConfig = {
+  max: 0,
+  before: void 0,
+  waitBeforeRetry: 0
+};
+let responseListeners = [];
+let errorsParser = void 0;
+let apiEndpoint = (0, import_endpoint.getApiEndpointCreator)({
+  getClient: () => ({ url, headers, retryConfig }),
+  responseListeners,
+  maxAge: 3e4,
+  verbose,
+  typesTree,
+  formatGraphQL,
+  errorsParser
+});
+const myApiClient = {
+  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: {
+    booksWithoutParams: apiEndpoint("query", "booksWithoutParams"),
+    booksWithOptionalParams: apiEndpoint("query", "booksWithOptionalParams"),
+    booksWithRequiredParams: apiEndpoint("query", "booksWithRequiredParams"),
+    failingQuery: apiEndpoint("query", "failingQuery")
+  },
+  mutations: {}
+};
+var stdin_default = myApiClient;

package/src/endpoint.ts

@@ -0,0 +1,117 @@
+import memoize from 'moize'
+import { graphqlRequest } from './graphqlRequest'
+import { jsonToGraphQLQuery } from './jsonToGraphQLQuery'
+import { logRequest } from './logging'
+import {ClientConfig, Endpoint, GraphQLClientError, IResponseListener, Projection, ResponseListenerInfo} from './types'
+
+const executeListeners = (listeners: IResponseListener[], data: ResponseListenerInfo) =>
+  setTimeout(() =>
+    listeners.forEach(runResponseListener =>
+      runResponseListener(data)
+    )
+  )
+
+export const getApiEndpointCreator =
+  (apiConfig: {
+    getClient: () => ClientConfig
+    responseListeners: IResponseListener[]
+    typesTree: any
+    maxAge: number
+    verbose: boolean
+    formatGraphQL: any
+    errorsParser?: (errors: any[]) => any
+  }) =>
+  <I = any, O = any, E = any>(kind: 'mutation' | 'query', queryName: string): Endpoint<I, O, E> => {
+    const rawEndpoint: any = async <S extends I>(
+      failureMode: 'loud' | 'silent',
+      jsonQuery?: S
+    ): Promise<{
+      data: Projection<S, O>
+      errors: any[]
+      warnings: any[]
+      headers: any
+      status: any
+    }> => {
+      const alias = (jsonQuery as any)?.__alias ?? queryName
+      const shouldRetry = (jsonQuery as any)?.__retry ?? true
+      const requestHeaders = (jsonQuery as any)?.__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: apiConfig.getClient(),
+          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: error as Error,
+            duration: +new Date() - start,
+          })
+        }
+
+        executeListeners(apiConfig.responseListeners, {
+          ...responseListenerData,
+          response: (error as GraphQLClientError).response,
+        })
+
+        throw error
+      }
+    }
+
+    const endpoint: any = async <S extends I>(jsonQuery?: S): Promise<Projection<S, O>> => {
+      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
+  }

package/src/generateTypescriptClient.test.ts

@@ -0,0 +1,127 @@
+import { ApolloServer } from 'apollo-server'
+import * as path from 'path'
+import { generateTypescriptClient } from './generateTypescriptClient'
+import { startServer } from './testServer'
+import { GraphQLClientError, ResponseListenerInfo } from './types'
+
+let testServer: { server: ApolloServer; url: string }
+let client: any
+
+describe('Generated Client', () => {
+  beforeAll(async () => {
+    testServer = await startServer()
+
+    const clientName = 'myApiClient'
+
+    const { js } = await generateTypescriptClient({
+      clientName,
+      endpoint: `${testServer.url}graphql`,
+      // For the sake of checking the generated code, we'll
+      // specify an output path
+      output: path.resolve(__dirname, './__testClient.ts'),
+      formatGraphQL: true,
+      skipCache: true,
+    })
+
+    client = eval(`${js};${clientName}`)
+  })
+
+  afterAll(async () => await testServer.server.stop())
+
+  it('should be able to pass custom headers to a query without args', async () => {
+    const books = await client.queries.booksWithoutParams({
+      __headers: { 'X-Custom-Header': 'Foo' },
+      title: true,
+      author: true,
+    })
+
+    expect(books).toHaveLength(2)
+    expect(books[0]).toHaveProperty('title')
+    expect(books[0]).toHaveProperty('author')
+  })
+
+  it('should be able to make queries with optional args, not passing args obj', async () => {
+    // noinspection TypeScriptValidateJSTypes
+    const books = await client.queries.booksWithOptionalParams({
+      title: true,
+      author: true,
+    })
+
+    expect(books).toHaveLength(2)
+    expect(books[0]).toHaveProperty('title')
+    expect(books[0]).toHaveProperty('author')
+  })
+
+  it('should be able to make queries with optional args, not passing args obj', async () => {
+    // noinspection TypeScriptValidateJSTypes
+    const books = await client.queries.booksWithOptionalParams({
+      __alias: 'helloWorld',
+      title: true,
+      author: true,
+    })
+
+    expect(books).toHaveLength(2)
+    expect(books[0]).toHaveProperty('title')
+    expect(books[0]).toHaveProperty('author')
+  })
+
+  it('fail with broken queries', async () => {
+    const result = await client.queries
+      .failingQuery({
+        __args: {
+          id: 'hello',
+        },
+      })
+      .then(
+        () => 'success',
+        (err: any) => err
+      )
+
+    expect(result).toBeInstanceOf(GraphQLClientError)
+    expect(result.message).toBe('Failed lorem ipsum dolor')
+  })
+
+  it('does not fail with broken queries when using raw requests', async () => {
+    const result = await client.queries.failingQuery.raw({
+      __args: {
+        id: 'hello',
+      },
+    })
+
+    expect(result.status).toBe(200)
+    expect(result.errors).toHaveLength(1)
+    expect(result.errors[0].message).toBe('Failed lorem ipsum dolor')
+  })
+
+  it('failing operations throw errors', async () => {
+    let failed = false
+
+    try {
+      await client.queries.failingQuery({
+        __args: {
+          id: 'hello',
+        },
+      })
+    } catch (err) {
+      failed = true
+    }
+
+    expect(failed).toBe(true)
+  })
+
+  it('failing operations throw errors', async () => {
+    let responseData: ResponseListenerInfo | undefined
+    client.addResponseListener((data: any) => (responseData = data))
+
+    try {
+      await client.queries.failingQuery({
+        __args: {
+          id: 'hello',
+        },
+      })
+    } catch {}
+
+    expect(responseData?.queryName).toBe('failingQuery')
+    expect(responseData?.response.errors.length).toBeGreaterThan(0)
+  })
+})