graphql-codegen-plugin-typescript-swr 0.8.4 → 0.8.6

package/dev-test/test-message/documents.ts

@@ -1,46 +0,0 @@
-import gql from 'graphql-tag';
-
-// tslint:disable-next-line:variable-name
-export const GetMessages = gql`
-  query GetMessages($tab: String!) {
-    messages(tab: $tab) {
-      id
-    }
-  }
-`;
-
-// tslint:disable-next-line:variable-name
-export const CreateMessage = gql`
-  mutation CreateMessage($args: CreateMessageInput!) {
-    createMessage(args: $args) {
-      id
-    }
-  }
-`;
-
-// tslint:disable-next-line:variable-name
-export const Decline = gql`
-  mutation Decline($id: ID!, $reason: String!) {
-    decline(id: $id, reason: $reason) {
-      id
-    }
-  }
-`;
-
-// tslint:disable-next-line:variable-name
-export const Approve = gql`
-  mutation Approve($id: ID!) {
-    approve(id: $id) {
-      id
-    }
-  }
-`;
-
-// tslint:disable-next-line:variable-name
-export const Escalate = gql`
-  mutation Escalate($id: ID!) {
-    escalate(id: $id) {
-      id
-    }
-  }
-`;

package/dev-test/test-message/schema.graphql

@@ -1,23 +0,0 @@
-type Message {
-  id: String!
-}
-
-type Query {
-  messages(tab: String!): [Message]
-}
-
-input CreateMessageInput {
-  description: String!
-}
-
-type Mutation {
-  createMessage(args: CreateMessageInput!): Message
-  approve(id: ID!): Message
-  decline(id: ID!, reason: String!): Message
-  escalate(id: ID!): Message
-}
-
-schema {
-  query: Query
-  mutation: Mutation
-}

package/dev-test/test-message/types.tsx

@@ -1,237 +0,0 @@
-import * as Operations from './documents';
-import * as Apollo from '@apollo/client';
-export type Maybe<T> = T | null;
-export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
-/** All built-in and custom scalars, mapped to their actual values */
-export type Scalars = {
-  ID: string;
-  String: string;
-  Boolean: boolean;
-  Int: number;
-  Float: number;
-};
-
-export type Message = {
-  __typename?: 'Message';
-  id: Scalars['String'];
-};
-
-export type Query = {
-  __typename?: 'Query';
-  messages?: Maybe<Array<Maybe<Message>>>;
-};
-
-export type QueryMessagesArgs = {
-  tab: Scalars['String'];
-};
-
-export type CreateMessageInput = {
-  description: Scalars['String'];
-};
-
-export type Mutation = {
-  __typename?: 'Mutation';
-  createMessage?: Maybe<Message>;
-  approve?: Maybe<Message>;
-  decline?: Maybe<Message>;
-  escalate?: Maybe<Message>;
-};
-
-export type MutationCreateMessageArgs = {
-  args: CreateMessageInput;
-};
-
-export type MutationApproveArgs = {
-  id: Scalars['ID'];
-};
-
-export type MutationDeclineArgs = {
-  id: Scalars['ID'];
-  reason: Scalars['String'];
-};
-
-export type MutationEscalateArgs = {
-  id: Scalars['ID'];
-};
-
-export type GetMessagesQueryVariables = Exact<{
-  tab: Scalars['String'];
-}>;
-
-export type GetMessagesQuery = { __typename?: 'Query' } & {
-  messages?: Maybe<Array<Maybe<{ __typename?: 'Message' } & Pick<Message, 'id'>>>>;
-};
-
-export type CreateMessageMutationVariables = Exact<{
-  args: CreateMessageInput;
-}>;
-
-export type CreateMessageMutation = { __typename?: 'Mutation' } & {
-  createMessage?: Maybe<{ __typename?: 'Message' } & Pick<Message, 'id'>>;
-};
-
-export type DeclineMutationVariables = Exact<{
-  id: Scalars['ID'];
-  reason: Scalars['String'];
-}>;
-
-export type DeclineMutation = { __typename?: 'Mutation' } & {
-  decline?: Maybe<{ __typename?: 'Message' } & Pick<Message, 'id'>>;
-};
-
-export type ApproveMutationVariables = Exact<{
-  id: Scalars['ID'];
-}>;
-
-export type ApproveMutation = { __typename?: 'Mutation' } & {
-  approve?: Maybe<{ __typename?: 'Message' } & Pick<Message, 'id'>>;
-};
-
-export type EscalateMutationVariables = Exact<{
-  id: Scalars['ID'];
-}>;
-
-export type EscalateMutation = { __typename?: 'Mutation' } & {
-  escalate?: Maybe<{ __typename?: 'Message' } & Pick<Message, 'id'>>;
-};
-
-/**
- * __useGetMessagesQuery__
- *
- * To run a query within a React component, call `useGetMessagesQuery` and pass it any options that fit your needs.
- * When your component renders, `useGetMessagesQuery` returns an object from Apollo Client that contains loading, error, and data properties
- * you can use to render your UI.
- *
- * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
- *
- * @example
- * const { data, loading, error } = useGetMessagesQuery({
- *   variables: {
- *      tab: // value for 'tab'
- *   },
- * });
- */
-export function useGetMessagesQuery(
-  baseOptions?: Apollo.QueryHookOptions<GetMessagesQuery, GetMessagesQueryVariables>
-) {
-  return Apollo.useQuery<GetMessagesQuery, GetMessagesQueryVariables>(Operations.GetMessages, baseOptions);
-}
-export function useGetMessagesLazyQuery(
-  baseOptions?: Apollo.LazyQueryHookOptions<GetMessagesQuery, GetMessagesQueryVariables>
-) {
-  return Apollo.useLazyQuery<GetMessagesQuery, GetMessagesQueryVariables>(Operations.GetMessages, baseOptions);
-}
-export type GetMessagesQueryHookResult = ReturnType<typeof useGetMessagesQuery>;
-export type GetMessagesLazyQueryHookResult = ReturnType<typeof useGetMessagesLazyQuery>;
-export type GetMessagesQueryResult = Apollo.QueryResult<GetMessagesQuery, GetMessagesQueryVariables>;
-
-/**
- * __useCreateMessageMutation__
- *
- * To run a mutation, you first call `useCreateMessageMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useCreateMessageMutation` returns a tuple that includes:
- * - A mutate function that you can call at any time to execute the mutation
- * - An object with fields that represent the current status of the mutation's execution
- *
- * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
- *
- * @example
- * const [createMessageMutation, { data, loading, error }] = useCreateMessageMutation({
- *   variables: {
- *      args: // value for 'args'
- *   },
- * });
- */
-export function useCreateMessageMutation(
-  baseOptions?: Apollo.MutationHookOptions<CreateMessageMutation, CreateMessageMutationVariables>
-) {
-  return Apollo.useMutation<CreateMessageMutation, CreateMessageMutationVariables>(
-    Operations.CreateMessage,
-    baseOptions
-  );
-}
-export type CreateMessageMutationHookResult = ReturnType<typeof useCreateMessageMutation>;
-export type CreateMessageMutationResult = Apollo.MutationResult<CreateMessageMutation>;
-export type CreateMessageMutationOptions = Apollo.BaseMutationOptions<
-  CreateMessageMutation,
-  CreateMessageMutationVariables
->;
-
-/**
- * __useDeclineMutation__
- *
- * To run a mutation, you first call `useDeclineMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useDeclineMutation` returns a tuple that includes:
- * - A mutate function that you can call at any time to execute the mutation
- * - An object with fields that represent the current status of the mutation's execution
- *
- * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
- *
- * @example
- * const [declineMutation, { data, loading, error }] = useDeclineMutation({
- *   variables: {
- *      id: // value for 'id'
- *      reason: // value for 'reason'
- *   },
- * });
- */
-export function useDeclineMutation(
-  baseOptions?: Apollo.MutationHookOptions<DeclineMutation, DeclineMutationVariables>
-) {
-  return Apollo.useMutation<DeclineMutation, DeclineMutationVariables>(Operations.Decline, baseOptions);
-}
-export type DeclineMutationHookResult = ReturnType<typeof useDeclineMutation>;
-export type DeclineMutationResult = Apollo.MutationResult<DeclineMutation>;
-export type DeclineMutationOptions = Apollo.BaseMutationOptions<DeclineMutation, DeclineMutationVariables>;
-
-/**
- * __useApproveMutation__
- *
- * To run a mutation, you first call `useApproveMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useApproveMutation` returns a tuple that includes:
- * - A mutate function that you can call at any time to execute the mutation
- * - An object with fields that represent the current status of the mutation's execution
- *
- * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
- *
- * @example
- * const [approveMutation, { data, loading, error }] = useApproveMutation({
- *   variables: {
- *      id: // value for 'id'
- *   },
- * });
- */
-export function useApproveMutation(
-  baseOptions?: Apollo.MutationHookOptions<ApproveMutation, ApproveMutationVariables>
-) {
-  return Apollo.useMutation<ApproveMutation, ApproveMutationVariables>(Operations.Approve, baseOptions);
-}
-export type ApproveMutationHookResult = ReturnType<typeof useApproveMutation>;
-export type ApproveMutationResult = Apollo.MutationResult<ApproveMutation>;
-export type ApproveMutationOptions = Apollo.BaseMutationOptions<ApproveMutation, ApproveMutationVariables>;
-
-/**
- * __useEscalateMutation__
- *
- * To run a mutation, you first call `useEscalateMutation` within a React component and pass it any options that fit your needs.
- * When your component renders, `useEscalateMutation` returns a tuple that includes:
- * - A mutate function that you can call at any time to execute the mutation
- * - An object with fields that represent the current status of the mutation's execution
- *
- * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
- *
- * @example
- * const [escalateMutation, { data, loading, error }] = useEscalateMutation({
- *   variables: {
- *      id: // value for 'id'
- *   },
- * });
- */
-export function useEscalateMutation(
-  baseOptions?: Apollo.MutationHookOptions<EscalateMutation, EscalateMutationVariables>
-) {
-  return Apollo.useMutation<EscalateMutation, EscalateMutationVariables>(Operations.Escalate, baseOptions);
-}
-export type EscalateMutationHookResult = ReturnType<typeof useEscalateMutation>;
-export type EscalateMutationResult = Apollo.MutationResult<EscalateMutation>;
-export type EscalateMutationOptions = Apollo.BaseMutationOptions<EscalateMutation, EscalateMutationVariables>;

package/dev-test/test-schema/env.types.ts

@@ -1,35 +0,0 @@
-export type Maybe<T> = T | null;
-export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
-/** All built-in and custom scalars, mapped to their actual values */
-export type Scalars = {
-  ID: string;
-  String: string;
-  Boolean: boolean;
-  Int: number;
-  Float: number;
-};
-
-export type User = {
-  __typename?: 'User';
-  id: Scalars['Int'];
-  name: Scalars['String'];
-  email: Scalars['String'];
-};
-
-export type Query = {
-  __typename?: 'Query';
-  allUsers: Array<Maybe<User>>;
-  userById?: Maybe<User>;
-  /**
-   *  Generates a new answer for th
-   * guessing game
-   */
-  answer: Array<Scalars['Int']>;
-  testArr1?: Maybe<Array<Maybe<Scalars['String']>>>;
-  testArr2: Array<Maybe<Scalars['String']>>;
-  testArr3: Array<Scalars['String']>;
-};
-
-export type QueryUserByIdArgs = {
-  id: Scalars['Int'];
-};

package/dev-test/test-schema/flow-types.flow.js

@@ -1,139 +0,0 @@
-// @flow
-
-import { type GraphQLResolveInfo } from 'graphql';
-export type $RequireFields<Origin, Keys> = $Diff<Origin, Keys> &
-  $ObjMapi<Keys, <Key>(k: Key) => $NonMaybeType<$ElementType<Origin, Key>>>;
-/** All built-in and custom scalars, mapped to their actual values */
-export type Scalars = {|
-  ID: string,
-  String: string,
-  Boolean: boolean,
-  Int: number,
-  Float: number,
-|};
-
-export type Query = {|
-  __typename?: 'Query',
-  allUsers: Array<?User>,
-  userById?: ?User,
-|};
-
-export type QueryUserByIdArgs = {|
-  id: $ElementType<Scalars, 'Int'>,
-|};
-
-export type User = {|
-  __typename?: 'User',
-  id: $ElementType<Scalars, 'Int'>,
-  name: $ElementType<Scalars, 'String'>,
-  email: $ElementType<Scalars, 'String'>,
-|};
-
-export type Resolver<Result, Parent = {}, Context = {}, Args = {}> = (
-  parent: Parent,
-  args: Args,
-  context: Context,
-  info: GraphQLResolveInfo
-) => Promise<Result> | Result;
-
-export type SubscriptionSubscribeFn<Result, Parent, Context, Args> = (
-  parent: Parent,
-  args: Args,
-  context: Context,
-  info: GraphQLResolveInfo
-) => AsyncIterator<Result> | Promise<AsyncIterator<Result>>;
-
-export type SubscriptionResolveFn<Result, Parent, Context, Args> = (
-  parent: Parent,
-  args: Args,
-  context: Context,
-  info: GraphQLResolveInfo
-) => Result | Promise<Result>;
-
-export interface SubscriptionSubscriberObject<Result, Key: string, Parent, Context, Args> {
-  subscribe: SubscriptionSubscribeFn<{ [key: Key]: Result }, Parent, Context, Args>;
-  resolve?: SubscriptionResolveFn<Result, { [key: Key]: Result }, Context, Args>;
-}
-
-export interface SubscriptionResolverObject<Result, Parent, Context, Args> {
-  subscribe: SubscriptionSubscribeFn<mixed, Parent, Context, Args>;
-  resolve: SubscriptionResolveFn<Result, mixed, Context, Args>;
-}
-
-export type SubscriptionObject<Result, Key: string, Parent, Context, Args> =
-  | SubscriptionSubscriberObject<Result, Key, Parent, Context, Args>
-  | SubscriptionResolverObject<Result, Parent, Context, Args>;
-
-export type SubscriptionResolver<Result, Key: string, Parent = {}, Context = {}, Args = {}> =
-  | ((...args: Array<any>) => SubscriptionObject<Result, Key, Parent, Context, Args>)
-  | SubscriptionObject<Result, Key, Parent, Context, Args>;
-
-export type TypeResolveFn<Types, Parent = {}, Context = {}> = (
-  parent: Parent,
-  context: Context,
-  info: GraphQLResolveInfo
-) => ?Types | Promise<?Types>;
-
-export type IsTypeOfResolverFn<T = {}, Context = {}> = (
-  obj: T,
-  context: Context,
-  info: GraphQLResolveInfo
-) => boolean | Promise<boolean>;
-
-export type NextResolverFn<T> = () => Promise<T>;
-
-export type DirectiveResolverFn<Result = {}, Parent = {}, Args = {}, Context = {}> = (
-  next: NextResolverFn<Result>,
-  parent: Parent,
-  args: Args,
-  context: Context,
-  info: GraphQLResolveInfo
-) => Result | Promise<Result>;
-
-export type ResolverTypeWrapper<T> = Promise<T> | T;
-
-/** Mapping between all available schema types and the resolvers types */
-export type ResolversTypes = {
-  Query: ResolverTypeWrapper<{}>,
-  Int: ResolverTypeWrapper<$ElementType<Scalars, 'Int'>>,
-  User: ResolverTypeWrapper<User>,
-  String: ResolverTypeWrapper<$ElementType<Scalars, 'String'>>,
-  Boolean: ResolverTypeWrapper<$ElementType<Scalars, 'Boolean'>>,
-};
-
-/** Mapping between all available schema types and the resolvers parents */
-export type ResolversParentTypes = {
-  Query: {},
-  Int: $ElementType<Scalars, 'Int'>,
-  User: User,
-  String: $ElementType<Scalars, 'String'>,
-  Boolean: $ElementType<Scalars, 'Boolean'>,
-};
-
-export type QueryResolvers<ContextType = any, ParentType = $ElementType<ResolversParentTypes, 'Query'>> = {
-  allUsers?: Resolver<Array<?$ElementType<ResolversTypes, 'User'>>, ParentType, ContextType>,
-  userById?: Resolver<
-    ?$ElementType<ResolversTypes, 'User'>,
-    ParentType,
-    ContextType,
-    $RequireFields<QueryUserByIdArgs, { id: * }>
-  >,
-};
-
-export type UserResolvers<ContextType = any, ParentType = $ElementType<ResolversParentTypes, 'User'>> = {
-  id?: Resolver<$ElementType<ResolversTypes, 'Int'>, ParentType, ContextType>,
-  name?: Resolver<$ElementType<ResolversTypes, 'String'>, ParentType, ContextType>,
-  email?: Resolver<$ElementType<ResolversTypes, 'String'>, ParentType, ContextType>,
-  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>,
-};
-
-export type Resolvers<ContextType = any> = {
-  Query?: QueryResolvers<ContextType>,
-  User?: UserResolvers<ContextType>,
-};
-
-/**
- * @deprecated
- * Use "Resolvers" root object instead. If you wish to get "IResolvers", add "typesPrefix: I" to your config.
- */
-export type IResolvers<ContextType = any> = Resolvers<ContextType>;

package/dev-test/test-schema/local/schema-ast.js

@@ -1,2 +0,0 @@
-const schemaFormats = require('./schema-formats');
-module.exports.schema = schemaFormats.schemaAst;

package/dev-test/test-schema/local/schema-formats.js

@@ -1,20 +0,0 @@
-/**
- * There are four formats the schema can be in:
- * 1. GraphQLSchema object
- * 2. Text (the GraphQL schema language textual format)
- * 3. AST (the GraphQL schema language textual format parsed into an AST)
- *
- * This file imports the textual and introspection json files and
- * exports all four formats to be used in tests.
- */
-
-const GraphQL = require('graphql');
-const fs = require('fs');
-const path = require('path');
-const schemaText = fs.readFileSync(path.join(__dirname, 'schema.graphql'), 'utf8');
-const schemaObject = GraphQL.buildSchema(schemaText);
-const schemaAst = GraphQL.parse(schemaText);
-
-module.exports.schemaText = schemaText;
-module.exports.schemaAst = schemaAst;
-module.exports.schemaObject = schemaObject;

package/dev-test/test-schema/local/schema-object.js

@@ -1,2 +0,0 @@
-const schemaFormats = require('./schema-formats');
-module.exports.schema = schemaFormats.schemaObject;

package/dev-test/test-schema/local/schema-text.js

@@ -1,2 +0,0 @@
-const schemaFormats = require('./schema-formats');
-module.exports.schema = schemaFormats.schemaText;

package/dev-test/test-schema/local/schema.graphql

@@ -1,8 +0,0 @@
-type Post {
-  id: Int!
-  title: String!
-}
-
-type Query {
-  allPosts: [Post]!
-}