@avantstay/graphql-ts-client 10.7.0 → 11.0.0-beta.1

package/dist/endpoint.d.ts

@@ -1,4 +1,4 @@
-import { C as ClientConfig, I as IResponseListener, E as Endpoint } from './types-4ecbabdf.js';
+import { C as ClientConfig, I as IResponseListener, E as Endpoint } from './types-4ada662b.js';
 
 declare const getApiEndpointCreator: (apiConfig: {
     getClient: () => ClientConfig;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 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-4ecbabdf.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, U as Unpacked } from './types-4ada662b.js';
 
 type IClientOptions = {
     output?: PathLike;

package/dist/index.js

@@ -487,7 +487,7 @@ var prettier = __toESM(require("prettier"));
 // package.json
 var package_default = {
     name: "@avantstay/graphql-ts-client",
-    version: "10.7.0",
+    version: "11.0.0-beta.1",
     description: "GraphQL Typescript Client Generator",
     author: "Wellington Guimaraes",
     license: "MIT",
@@ -683,8 +683,7 @@ function gqlEndpointToCode(kind, endpoint, codeOutputType) {
     var outputType = gqlTypeToTypescript(endpoint.type, {
         required: true
     });
-    var wrappedOutputType = /^(string|number|boolean)$/.test(outputType) ? outputType : "DeepRequired<".concat(outputType, ">");
-    return codeOutputType === "ts" ? "".concat(endpoint.name, ": Endpoint<").concat(inputType, ", ").concat(wrappedOutputType, ", AllEnums>") : "".concat(endpoint.name, ": apiEndpoint('").concat(kind, "', '").concat(endpoint.name, "')");
+    return codeOutputType === "ts" ? "".concat(endpoint.name, ": Endpoint<").concat(inputType, ", ").concat(outputType, ", AllEnums>") : "".concat(endpoint.name, ": apiEndpoint('").concat(kind, "', '").concat(endpoint.name, "')");
 }
 function gqlSchemaToCode(gqlType, param) {
     var _param_selection = param.selection, selection = _param_selection === void 0 ? false : _param_selection, outputType = param.outputType;

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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@avantstay/graphql-ts-client",
-  "version": "10.7.0",
+  "version": "11.0.0-beta.1",
   "description": "GraphQL Typescript Client Generator",
   "author": "Wellington Guimaraes",
   "license": "MIT",

package/src/__testClient.d.ts

@@ -0,0 +1,164 @@
+// 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 Image {
+  url?: string
+  alt?: string
+}
+
+/**
+ * @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
+  images?: Image[]
+}
+
+/**
+ * @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 ImageSelection {
+  url?: boolean
+  alt?: boolean
+}
+
+export interface BookSelection {
+  title?: boolean
+  author?: boolean
+  type?: boolean
+  dateCreated?: boolean
+  images?: ImageSelection
+}
+
+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,
+      Book[],
+      AllEnums
+    >
+    booksWithOptionalParams: Endpoint<
+      {
+        __headers?: { [key: string]: string }
+        __retry?: boolean
+        __alias?: string
+        __args?: BooksWithOptionalParamsArgs
+      } & BookSelection,
+      Book[],
+      AllEnums
+    >
+    booksWithRequiredParams: Endpoint<
+      {
+        __headers?: { [key: string]: string }
+        __retry?: boolean
+        __alias?: string
+        __args: BooksWithRequiredParamsArgs
+      } & BookSelection,
+      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,119 @@
+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 __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  BookType: () => BookType,
+  default: () => stdin_default,
+  myApiClient: () => myApiClient
+});
+var import_endpoint = __toModule(require("./endpoint"));
+var import_standalone = __toModule(require("prettier/standalone"));
+var import_parser_graphql = __toModule(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 {
+        __fields: typesTree.Book,
+        __args: {
+          params: "BookSearchParamsAllOptional!"
+        }
+      };
+    },
+    get booksWithRequiredParams() {
+      return {
+        __fields: typesTree.Book,
+        __args: {
+          params: "BookSearchParamsSomeRequired!"
+        }
+      };
+    },
+    get failingQuery() {
+      return {
+        __args: {
+          id: "String!"
+        }
+      };
+    },
+    get booksWithoutParams() {
+      return {
+        __fields: typesTree.Book
+      };
+    }
+  },
+  Book: {
+    images: {}
+  }
+};
+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/generateTypescriptClient.ts

@@ -152,10 +152,9 @@ function gqlEndpointToCode(kind: 'mutation' | 'query', endpoint: IntrospectionFi
   }${selectionType ? ` & ${selectionType}` : ''}`
 
   const outputType = gqlTypeToTypescript(endpoint.type, { required: true })
-  const wrappedOutputType = /^(string|number|boolean)$/.test(outputType) ? outputType : `DeepRequired<${outputType}>`
 
   return codeOutputType === 'ts'
-    ? `${endpoint.name}: Endpoint<${inputType}, ${wrappedOutputType}, AllEnums>`
+    ? `${endpoint.name}: Endpoint<${inputType}, ${outputType}, AllEnums>`
     : `${endpoint.name}: apiEndpoint('${kind}', '${endpoint.name}')`
 }
 

package/src/types.ts

@@ -21,11 +21,14 @@ export type IResponseListener = (info: ResponseListenerInfo) => void | Promise<v
 
 type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never
 
+type Primitive = Date | string | number | boolean | null | undefined
+
+// Projection is the resulting type of Selection (type generated out of a query) applied to Base (generated graphql type)
 export type Projection<Selection, Base, E = never> = Base extends Array<any>
-  ? ArrayElement<Base> extends Date | string | number | boolean | null | undefined | E
+  ? ArrayElement<Base> extends Primitive | E
     ? ArrayElement<Base>[]
     : Projection<Defined<Selection>, ArrayElement<Base>, E>[]
-  : Base extends Date | string | number | boolean | null | E
+  : Base extends Primitive | E
   ? // Is primitive and extends undefined
     Selection extends undefined
     ? Base | undefined