npm package: @mutix/graphql-phoenix
Author: Mutix
Latest version: 0.1.25

# graphql-phoenix


功能: 
- 檢查 resolvers 必須要 type name (Author) 要有
- 檢查 `implements Node` 必須存在
- 檢查 `id` 欄位為必須
- 用 `hasTimestamp` 設定node是否需要有 timestamp 相關欄位
- 用 `hasOperator`
- 如果欄位是 `node type` 卻沒有寫 `resolver`

```js
export default makeNode({
  softDelete: false,
  hasOperator: false,
  hasTimestamp: false,
  typeDefs: gql`
    union Works = Book | Music

    type Author implements Node {
      id: GlobalID
      name: String
      avatar: Media
      works: [Works]
      numberOfFollowers: Int
      createdAt: DateTime
      createdBy: User
      updatedAt: DateTime
      updatedBy: User
    }

    enum AuthorOrderBy {
      createdAt
      updatedAt
      numberOfFollowers
    }

    input AuthorFilter {
      name: StringArgument
      avatar: GlobalIDArgument
      works: GlobalIDArgument
      numberOfFollowers: IntArgument
      createdAt: DateTimeArgument
      createdBy: GlobalIDArgument
      updatedAt: DateTimeArgument
      updatedBy: GlobalIDArgument
    }

    input AddAuthorInput {
      name: String
      avatar: Media
      works: [Works]
      numberOfFollowers: Int
    }
  
    input UpdateAuthorInput {
      id: GlobalID
      name: String
      avatar: Media
      works: [Works]
      numberOfFollowers: Int
    }
  `,
  resolvers: {
    Author: {
      id: (source) => source.id,
      avatar: (source, args, { models }) => models.load(source.avatar),
      works: (source, args, { models }) => models.loadMany(source.works),
      numberOfFollowers: () => {},
      createdAt: () => {},
      updatedAt: () => {},
      createdBy: (source, args, { models }) => models.load(source.createdBy),
      updatedBy: (source, args, { models }) => models.load(source.updatedBy),
    }
  }
})
```

- 檢查必須要 Query 要有
- 檢查必須要是 `extend type Query`

```js
export default makeQuery({
  typeDefs: gql`
    extend type Query {
      node(id: GlobalID!): Node
    }
  `,
  resolvers: {
    Query: {
      node: (source, args, { models }) => models.load(args.id),
    },
  },
});
```

- 繼承 makeQuery 的功能
- 檢查 `first` 與 `cursor` 為必須
- 檢查 `filter` 與 `orderBy` 為必須
- 檢查 `[name]Pagination` 大駝峰並加上 `Pagination`
- 檢查 `AuthorsPagination` 裡面的必要欄位


```js
export default makeQueryPagination({
  typeDefs: gql`
    extend type Query {
      authors(
        first: First
        cursor: Cursor
        filter: AuthorFilter
        orderBy: AuthorOrderBy
      ): AuthorsPagination
    }

    type AuthorsPagination {
      totalCount: Int
      nodes: [Author]
      pageInfo {
        next: Cursor
        previous: Cursor
      }
    }

    type AuthorFilter {
    }
  `,
  resolvers: {
    Query: {
      authors: (source, args, { models }) => {
        const { AuthorQuery } = models;
        if (args.cursor) {
          AuthorQuery.cursor(args.cursor);
        } else {
          AuthorQuery.filterQL(args.filter);
          AuthorQuery.sortByQL(args.sortBy);
        }
        AuthorQuery.first(args.first);
        AuthorQuery.where(...);
        return AuthorQuery;
      }
    },
    AuthorsPagination: {
      totalCount: (source) => {},
      nodes: (source) => source.find(),
      pageInfo: (source) => ,
    }
  },
});
```

- 檢查 `extend type Mutation`
- 檢查 `[name]MutationPayload`
- 檢查 `status` 必須
- 檢查必須要 Mutation 要有

```js
export default makeMutation({
  typeDefs: gql`
    extend type Mutation {
      addAuthor(input: AddAuthorInput): AddAuthorMutationPayload
    }

    type AddAuthorMutationPayload {
      status: ResponseStatus
      author: Author
    }
  `,
  resolvers: {
    Mutation: {
      addAuthor: () => {}
    },
  },
});
```

```js
export default makeMutation({
  typeDefs: gql`
    extend type Mutation {
      updateAuthor(input: UpdateAuthorInput): UpdateAuthorMutationPayload
    }

    type UpdateAuthorMutationPayload {
      status: ResponseStatus
      author: Author
    }
  `,
  resolvers: {
    Mutation: {
      updateAuthor: () => {}
    },
  },
});
```