93 | ): React.ReactNode {
94 | return [
95 | ,
98 |
99 | {this.input(type, input, inputHtml, selectOptions)}
100 |
101 | ];
102 | }
103 |
104 | private checkboxWrapper(type: string, input: IFormInput, inputHtml: any): React.ReactNode {
105 | return (
106 |
107 |
111 |
112 | );
113 | }
114 |
115 | private fileWrapper(type: string, input: IFormInput, inputHtml: any) {
116 | const value = input.value;
117 | const filename = value && value.name;
118 | const newInputHtml = { ...inputHtml, className: classnames(inputHtml.className, 'file-input') };
119 |
120 | return (
121 |
122 |
132 |
133 | );
134 | }
135 |
136 | public render() {
137 | const { type, meta, className, hint, input, inputHtml, options: selectOptions } = this.props;
138 |
139 | let wrapper: React.ReactNode = null;
140 | switch (type) {
141 | case 'checkbox':
142 | wrapper = this.checkboxWrapper(type, input, inputHtml);
143 | break;
144 | case 'file':
145 | wrapper = this.fileWrapper(type, input, inputHtml);
146 | break;
147 | default:
148 | wrapper = this.defaultWrapper(type, input, inputHtml, selectOptions);
149 | }
150 |
151 | return (
152 |
153 | {wrapper}
154 | {(meta.error || meta.submitError) &&
155 | meta.touched &&
{meta.error || meta.submitError}
}
156 | {hint &&
{hint}
}
157 |
25 |
26 |
33 |
34 | {cancel ? (
35 |
36 |
37 | Back
38 |
39 |
40 | ) : null}
41 |
17 |
{comment.content}
18 |
19 |
20 | Commented by: {comment.author.name}
21 |
22 | {moment(new Date(comment.created_at)).fromNow()}
23 |
24 |
65 | You need to sign in or sign up before
66 | continuing.
67 |
68 | );
69 | }
70 |
71 | return (
72 |
73 |
83 | )}
84 | />
85 |
86 | );
87 | }
88 | }
89 |
90 | type CurrentUserProps = {
91 | currentUser: User;
92 | };
93 |
94 | const withCreateComment = graphql<
95 | CreateCommentMutation,
96 | CreateCommentMutationVariables & MutationStateProps & CurrentUserProps
97 | >(CREATE_COMMENT, {
98 | props: ({ ownProps, mutate }) => ({
99 | createComment(postId: string, comment: CreateCommentMutationVariables) {
100 | return ownProps.wrapMutate(
101 | mutate!({
102 | variables: { postId, ...comment },
103 | update: (store: DataProxy, { data: { createComment: { newComment } } }: any): void => {
104 | if (!newComment) return;
105 | const id = ownProps.postId;
106 | const data = store.readQuery({ query: POST, variables: { id } }) as PostQuery;
107 | if (!data || !data.post) return;
108 |
109 | data.post.comments.unshift(newComment);
110 | store.writeQuery({ query: POST, variables: { id }, data });
111 | },
112 | optimisticResponse: {
113 | __typename: 'Mutation',
114 | createComment: {
115 | __typename: 'Post',
116 | newComment: {
117 | __typename: 'Comment',
118 | id: shortid.generate(),
119 | content: comment.content,
120 | created_at: +new Date(),
121 | pending: true,
122 | author: {
123 | __typename: 'User',
124 | name: ownProps.currentUser.name
125 | }
126 | },
127 | messages: null
128 | }
129 | }
130 | })
131 | );
132 | }
133 | })
134 | });
135 |
136 | export default compose(
137 | withCurrentUser,
138 | withMutationState({ wrapper: true, propagateError: true }),
139 | withCreateComment,
140 | withFlashMessage
141 | )(NewComment);
142 |
--------------------------------------------------------------------------------
/client/src/containers/layouts/App.tsx:
--------------------------------------------------------------------------------
1 | import * as React from 'react';
2 | import { compose } from 'react-apollo';
3 | import { withRouter } from 'react-router';
4 | import { Route, Switch } from 'react-router-dom';
5 |
6 | import AllPosts from 'containers/posts/AllPosts';
7 | import SearchPosts from 'containers/posts/SearchPosts';
8 | import Post from 'containers/posts/Post';
9 | import NewPost from 'containers/posts/NewPost';
10 | import EditPost from 'containers/posts/EditPost';
11 |
12 | import SignInUser from 'containers/users/SignInUser';
13 | import SignUpUser from 'containers/users/SignUpUser';
14 | import EditUserProfile from 'containers/users/EditUserProfile';
15 | import ChangeUserPassword from 'containers/users/ChangeUserPassword';
16 |
17 | import UserIsAuthenticated from 'components/UserIsAuthenticated';
18 | import NotFound from 'components/NotFound';
19 | import Header from 'containers/layouts/Header';
20 |
21 | import FlashMessage from 'components/flash/FlashMessage';
22 | import withFlashMessage from 'components/flash/withFlashMessage';
23 | import withCurrentUser from 'queries/currentUserQuery';
24 |
25 | import 'assets/stylesheets/css/application.css';
26 |
27 | // typings
28 | import { User } from 'types';
29 | import { History } from 'history';
30 |
31 | interface IProps {
32 | history: History;
33 | deleteFlashMessage: () => void;
34 | currentUser: User;
35 | currentUserLoading: boolean;
36 | }
37 |
38 | class App extends React.Component {
39 | private unsubscribeFromHistory: any;
40 |
41 | public componentWillMount() {
42 | const { history } = this.props;
43 | this.unsubscribeFromHistory = history.listen(this.handleLocationChange);
44 | this.handleLocationChange();
45 | }
46 |
47 | public componentWillUnmount() {
48 | if (this.unsubscribeFromHistory) this.unsubscribeFromHistory();
49 | }
50 |
51 | public handleLocationChange = () => {
52 | this.props.deleteFlashMessage();
53 | };
54 |
55 | public render() {
56 | const { currentUser, currentUserLoading } = this.props;
57 |
58 | return (
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
85 |
57 |
58 | Register
59 |
60 |
61 | Login
62 |
63 |
64 | );
65 | }
66 |
67 | public render() {
68 | return (
69 |
70 |
71 |
79 |
29 |
Listing posts
30 |
31 |
32 |
33 |
34 |
35 | );
36 | }
37 | }
38 |
39 | export default compose(withPosts)(AllPosts);
40 |
--------------------------------------------------------------------------------
/client/src/containers/posts/EditPost.tsx:
--------------------------------------------------------------------------------
1 | import * as React from 'react';
2 | import { graphql, compose } from 'react-apollo';
3 | import withMutationState from 'apollo-mutation-state';
4 |
5 | import PostForm from 'containers/posts/_PostForm';
6 | import withFlashMessage from 'components/flash/withFlashMessage';
7 |
8 | import POST_FOR_EDITING from 'graphql/posts/postForEditingQuery.graphql';
9 | import UPDATE_POST from 'graphql/posts/updatePostMutation.graphql';
10 |
11 | // typings
12 | import { ApolloQueryResult } from 'apollo-client/core/types';
13 | import {
14 | FlashMessageVariables,
15 | UpdatePostMutation,
16 | UpdatePostMutationVariables,
17 | PostForEditingQuery,
18 | PostFragment,
19 | MutationState,
20 | MutationStateProps
21 | } from 'types';
22 |
23 | interface IProps {
24 | redirect: (path: string, message: FlashMessageVariables) => void;
25 | updatePost: ({ }: UpdatePostMutationVariables) => Promise>;
26 | data: PostForEditingQuery;
27 | mutation: MutationState;
28 | }
29 |
30 | class EditPost extends React.Component {
31 | constructor(props: IProps) {
32 | super(props);
33 | this.action = this.action.bind(this);
34 | }
35 |
36 | private async action(values: any) {
37 | return new Promise(async (_, reject) => {
38 | const { data: { updatePost: { errors } } } = await this.props.updatePost(values);
39 | if (!errors) {
40 | this.props.redirect('/', { notice: 'Post was successfully updated' });
41 | } else {
42 | reject(errors);
43 | }
44 | });
45 | }
46 |
47 | public render() {
48 | const { data: { post } } = this.props;
49 | if (!post) {
50 | return null;
51 | }
52 |
53 | return (
54 |
55 |
Editing post
56 |
62 |
44 |
45 |
{post.title}
46 |
47 | {currentUser && currentUser.id === post.author.id ?
: null}
48 |
49 |
50 |
51 |
52 |
{post.content}
53 |
54 |
Comments
55 | {this.listComments(post)}
56 |
57 |
58 |
35 |
Search: {keywords}
36 |
37 |
38 |
39 |
40 | {posts && posts.length === 0 ? (
41 | No results ...
42 | ) : (
43 |
44 | )}
45 |
46 | );
47 | }
48 | }
49 |
50 | export default compose(withPosts)(SearchPosts);
51 |
--------------------------------------------------------------------------------
/client/src/containers/posts/_HeadListPosts.tsx:
--------------------------------------------------------------------------------
1 | import * as React from 'react';
2 | import { compose } from 'react-apollo';
3 | import { Link } from 'react-router-dom';
4 |
5 | import SearchForm from 'containers/posts/_SearchForm';
6 | import withCurrentUser from 'queries/currentUserQuery';
7 |
8 | // typings
9 | import { User } from 'types';
10 |
11 | interface IProps {
12 | keywords: string;
13 | currentUser: User;
14 | }
15 |
16 | class HeadListRecipes extends React.Component {
17 | public render() {
18 | const { keywords, currentUser } = this.props;
19 |
20 | return (
21 |
22 |
27 | {currentUser ? (
28 |
29 |
30 | New Post
31 |
32 |
33 | ) : null}
34 |
25 | {posts.map(post =>
)}
26 |
27 | {posts && posts.length < postsCount ? (
28 |
31 | ) : null}
32 |
17 | By {post.author.name} -
18 | {moment(new Date(post.created_at)).fromNow()}
19 |
20 | );
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/client/src/containers/posts/_PostPreview.tsx:
--------------------------------------------------------------------------------
1 | import * as React from 'react';
2 | import { compose } from 'react-apollo';
3 | import { Link } from 'react-router-dom';
4 |
5 | import PostInfos from 'containers/posts/_PostInfos';
6 | import PostActions from 'containers/posts/_PostActions';
7 | import withCurrentUser from 'queries/currentUserQuery';
8 |
9 | // typings
10 | import { PostPreviewFragment, User } from 'types';
11 |
12 | interface IProps {
13 | post: PostPreviewFragment;
14 | currentUser: User;
15 | }
16 |
17 | class PostPreview extends React.Component {
18 | public render() {
19 | const { post, currentUser } = this.props;
20 |
21 | return (
22 |
23 |
24 |
25 |
26 | {post.title}
27 |
28 | {currentUser && currentUser.id === post.author.id ?
: null}
29 |
30 |
31 |
32 |
{post.description}
33 |
34 |
55 |
56 |
57 |
Changer votre mot de passe
58 |
75 | )}
76 | />
77 |
78 |
79 |
69 |
70 |
71 |
Edit profile
72 |
81 | )}
82 | />
83 |
84 |
85 |
Password
86 |
87 |
88 |
89 |
90 | Change password
91 |
92 |
93 |
94 |
103 |
104 |
105 |
79 |
80 |
91 | )}
92 | />
93 | Sign up
94 |
95 |
64 |
65 |
83 | )}
84 | />
85 | Log in
86 |
87 |
118 |
119 | #### Creating comments
120 |
121 | 
122 |
123 | #### Post page
124 |
125 | 
126 |
127 | #### Editing post
128 |
129 | 
130 |
131 | ## License
132 |
133 | MIT © [Matthieu Segret](http://matthieusegret.com)
134 |
--------------------------------------------------------------------------------
/Rakefile:
--------------------------------------------------------------------------------
1 | # Add your own tasks in files placed in lib/tasks ending in .rake,
2 | # for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
3 |
4 | require_relative 'config/application'
5 |
6 | Rails.application.load_tasks
7 |
--------------------------------------------------------------------------------
/app/controllers/application_controller.rb:
--------------------------------------------------------------------------------
1 | class ApplicationController < ActionController::Base
2 | include Authenticatable
3 | before_action :authenticate
4 |
5 | def index
6 | render file: 'public/index.html'
7 | end
8 | end
9 |
--------------------------------------------------------------------------------
/app/controllers/concerns/authenticatable.rb:
--------------------------------------------------------------------------------
1 | module Authenticatable
2 | def authenticate
3 | if request.headers["Authorization"].present?
4 | pattern = /^Bearer /
5 | header = request.headers['Authorization']
6 | token = header.gsub(pattern, '') if header && header.match(pattern)
7 |
8 | if token.present?
9 | @current_user = User.find_by_access_token(token)
10 |
11 | if @current_user.nil?
12 | render json: FieldError.error("Auth token is invalid")
13 | end
14 | end
15 | end
16 | end
17 |
18 | def current_user
19 | @current_user
20 | end
21 | end
--------------------------------------------------------------------------------
/app/controllers/graphql_controller.rb:
--------------------------------------------------------------------------------
1 | class GraphqlController < ApplicationController
2 | def create
3 | if params[:query].present?
4 | # Execute one query
5 | query_string, variables = params[:query], params[:variables]
6 | result = execute(query_string, variables)
7 | else
8 | # Execute multi queries
9 | queries_params = params[:_json]
10 | result = multiplex(queries_params)
11 | end
12 |
13 | render json: result
14 | end
15 |
16 |
17 | private
18 |
19 | # Execute one query
20 | def execute(query_string, variables)
21 | puts GraphQLFormatter.new(query_string) if Rails.env.development?
22 | query_variables = ensure_hash(params[:variables])
23 | result = Schema.execute(
24 | query_string,
25 | variables: query_variables,
26 | context: {
27 | current_user: current_user,
28 | request: request
29 | })
30 | end
31 |
32 | # Execute multi queries
33 | def multiplex(queries_params)
34 | if Rails.env.development?
35 | queries_params.each { |query| puts GraphQLFormatter.new(query[:query]) }
36 | end
37 |
38 | queries = queries_params.map do |query|
39 | {
40 | query: query[:query],
41 | variables: ensure_hash(query[:variables]),
42 | context: {
43 | current_user: current_user,
44 | request: request,
45 | optics_agent: (Rails.env.production? ? request.env[:optics_agent].with_document(query[:query]) : nil)
46 | }
47 | }
48 | end
49 |
50 | Schema.multiplex(queries)
51 | end
52 |
53 | def ensure_hash(query_variables)
54 | if query_variables.blank?
55 | {}
56 | elsif query_variables.is_a?(String)
57 | JSON.parse(query_variables)
58 | else
59 | query_variables
60 | end
61 | end
62 | end
63 |
--------------------------------------------------------------------------------
/app/graph/mutations/auth_mutations.rb:
--------------------------------------------------------------------------------
1 | module AuthMutations
2 | SignIn = GraphQL::Relay::Mutation.define do
3 | name "signIn"
4 | description "SignIn"
5 |
6 | input_field :email, types.String
7 | input_field :password, types.String
8 |
9 | return_field :token, types.String
10 | return_field :messages, types[FieldErrorType]
11 |
12 | resolve ->(obj, inputs, ctx) {
13 | user = User.find_by(email: inputs[:email])
14 | if user.present? && user.authenticate(inputs[:password])
15 | user.update_tracked_fields(ctx[:request])
16 | { token: user.generate_access_token! }
17 | else
18 | FieldError.error("Invalid email or password")
19 | end
20 | }
21 | end
22 |
23 | RevokeToken = GraphQL::Relay::Mutation.define do
24 | name "revokeToken"
25 | description "revoke token"
26 | return_field :messages, types[FieldErrorType]
27 |
28 | resolve(Auth.protect ->(obj, inputs, ctx) {
29 | ctx[:current_user].update(access_token: nil)
30 | {}
31 | })
32 | end
33 | end
--------------------------------------------------------------------------------
/app/graph/mutations/comment_mutations.rb:
--------------------------------------------------------------------------------
1 | module CommentMutations
2 | Create = GraphQL::Relay::Mutation.define do
3 | name "createComment"
4 | description "create Comment"
5 |
6 | input_field :postId, types.ID
7 | input_field :content, types.String
8 |
9 | return_field :comment, CommentType
10 | return_field :messages, types[FieldErrorType]
11 |
12 | resolve(Auth.protect ->(obj, inputs, ctx) {
13 | post = Post.find(inputs[:postId])
14 | new_comment = post.comments.build(content: inputs[:content])
15 | new_comment.user = ctx[:current_user]
16 |
17 | if new_comment.save
18 | { comment: new_comment }
19 | else
20 | { messages: new_comment.fields_errors }
21 | end
22 | })
23 | end
24 | end
25 |
--------------------------------------------------------------------------------
/app/graph/mutations/post_mutations.rb:
--------------------------------------------------------------------------------
1 | module PostMutations
2 | Create = GraphQL::Relay::Mutation.define do
3 | name "createPost"
4 | description "create Post"
5 |
6 | input_field :title, types.String
7 | input_field :content, types.String
8 |
9 | return_field :post, PostType
10 | return_field :messages, types[FieldErrorType]
11 |
12 | resolve(Auth.protect ->(obj, inputs, ctx) {
13 | new_post = ctx[:current_user].posts.build(inputs.to_params)
14 |
15 | if new_post.save
16 | { post: new_post }
17 | else
18 | { messages: new_post.fields_errors }
19 | end
20 | })
21 | end
22 |
23 | Update = GraphQL::Relay::Mutation.define do
24 | name "updatePost"
25 | description "Update a Post and return Post"
26 |
27 | input_field :id, types.ID
28 | input_field :title, types.String
29 | input_field :content, types.String
30 |
31 | return_field :post, PostType
32 | return_field :messages, types[FieldErrorType]
33 |
34 | resolve(Auth.protect ->(obj, inputs, ctx) {
35 | post = Post.find(inputs[:id])
36 |
37 | if ctx[:current_user] != post.user
38 | FieldError.error("You can not modify this post because you are not the owner")
39 | elsif post.update(inputs.to_params)
40 | { post: post }
41 | else
42 | { messages: post.fields_errors }
43 | end
44 | })
45 | end
46 |
47 | Destroy = GraphQL::Relay::Mutation.define do
48 | name "deletePost"
49 | description "Destroy a Post"
50 | input_field :id, types.ID
51 |
52 | return_field :post, PostType
53 | return_field :messages, types[FieldErrorType]
54 |
55 | resolve(Auth.protect ->(obj, inputs, ctx) {
56 | post = Post.find(inputs[:id])
57 |
58 | if ctx[:current_user] != post.user
59 | FieldError.error("You can not modify this post because you are not the owner")
60 | elsif post.destroy
61 | { post: post }
62 | end
63 | })
64 | end
65 | end
66 |
--------------------------------------------------------------------------------
/app/graph/mutations/user_mutations.rb:
--------------------------------------------------------------------------------
1 | module UserMutations
2 | SignUp = GraphQL::Relay::Mutation.define do
3 | name "signUp"
4 | description "Sign up"
5 |
6 | input_field :name, types.String
7 | input_field :email, types.String
8 | input_field :password, types.String
9 | input_field :password_confirmation, types.String
10 |
11 | return_field :user, UserType
12 | return_field :messages, types[FieldErrorType]
13 |
14 | resolve ->(obj, inputs, ctx) {
15 | user = User.new(inputs.to_params)
16 |
17 | if user.save
18 | user.update_tracked_fields(ctx[:request])
19 | user.generate_access_token!
20 | { user: user }
21 | else
22 | { messages: user.fields_errors }
23 | end
24 | }
25 | end
26 |
27 | Update = GraphQL::Relay::Mutation.define do
28 | name "updateUser"
29 | description "Update user"
30 |
31 | input_field :name, types.String
32 | input_field :email, types.String
33 |
34 | return_field :user, UserType
35 | return_field :messages, types[FieldErrorType]
36 |
37 | resolve(Auth.protect ->(obj, inputs, ctx) {
38 | current_user = ctx[:current_user]
39 |
40 | if current_user.update(inputs.to_params)
41 | { user: current_user }
42 | else
43 | { messages: current_user.fields_errors }
44 | end
45 | })
46 | end
47 |
48 | ChangePassword = GraphQL::Relay::Mutation.define do
49 | name "changePassword"
50 | description "Change user password"
51 |
52 | input_field :password, types.String
53 | input_field :password_confirmation, types.String
54 | input_field :current_password, types.String
55 |
56 | return_field :user, UserType
57 | return_field :messages, types[FieldErrorType]
58 |
59 | resolve(Auth.protect ->(obj, inputs, ctx) {
60 | current_user = ctx[:current_user]
61 | params_with_password = inputs.to_h.symbolize_keys
62 | if current_user.update_with_password(params_with_password)
63 | { user: current_user }
64 | else
65 | { messages: current_user.fields_errors }
66 | end
67 | })
68 | end
69 |
70 | CancelAccount = GraphQL::Relay::Mutation.define do
71 | name "cancelAccount"
72 | description "Cancel Account"
73 |
74 | return_type types.Boolean
75 |
76 | resolve(Auth.protect ->(obj, inputs, ctx) {
77 | ctx[:current_user].destroy
78 | true
79 | })
80 | end
81 | end
82 |
--------------------------------------------------------------------------------
/app/graph/schema.rb:
--------------------------------------------------------------------------------
1 | Schema = GraphQL::Schema.define do
2 | query QueryType
3 | mutation MutationType
4 |
5 | instrument :query, ConcurrentBatchSetup
6 | lazy_resolve GraphQL::Batch::Promise, :sync
7 | end
8 |
--------------------------------------------------------------------------------
/app/graph/types/comment_type.rb:
--------------------------------------------------------------------------------
1 | CommentType = GraphQL::ObjectType.define do
2 |
3 | name "Comment"
4 | description "A post comment with content and author"
5 |
6 | field :id, !types.ID
7 | field :content, types.String, "The content of this comment"
8 | field :created_at, types.String, "The date on which the comment was posted"
9 |
10 | field :author, UserType, "Owner of this comment" do
11 | resolve ->(comment, args, ctx) {
12 | RecordLoader.for(User).load(comment.user_id)
13 | }
14 | end
15 | end
16 |
--------------------------------------------------------------------------------
/app/graph/types/field_error_type.rb:
--------------------------------------------------------------------------------
1 | FieldErrorType = GraphQL::ObjectType.define do
2 | name "FieldError"
3 | description "Information about field that didn’t pass validation"
4 |
5 | # Expose fields from the model
6 | field :field, types.String, "Field name that caused these errors"
7 | field :message, !types.String, "Validation message"
8 | end
9 |
--------------------------------------------------------------------------------
/app/graph/types/mutation_type.rb:
--------------------------------------------------------------------------------
1 | MutationType = GraphQL::ObjectType.define do
2 | name 'Mutation'
3 |
4 | field :createPost, field: PostMutations::Create.field
5 | field :updatePost, field: PostMutations::Update.field
6 | field :deletePost, field: PostMutations::Destroy.field
7 |
8 | field :createComment, field: CommentMutations::Create.field
9 |
10 | field :signIn, field: AuthMutations::SignIn.field
11 | field :revokeToken, field: AuthMutations::RevokeToken.field
12 |
13 | field :signUp, field: UserMutations::SignUp.field
14 | field :updateUser, field: UserMutations::Update.field
15 | field :changePassword, field: UserMutations::ChangePassword.field
16 | field :cancelAccount, field: UserMutations::CancelAccount.field
17 | end
18 |
--------------------------------------------------------------------------------
/app/graph/types/post_type.rb:
--------------------------------------------------------------------------------
1 | PostType = GraphQL::ObjectType.define do
2 | name "Post"
3 | description "A blog post with title, content, author and total comments"
4 |
5 | field :id, !types.ID
6 | field :title, types.String, "The title of this post"
7 | field :content, types.String, "The content of this post"
8 | field :comments_count, types.String, "The total numner of comments on this post"
9 | field :created_at, types.String, "The time at which this post was created"
10 | field :description, types.String, "The beginning of the content"
11 |
12 | field :author, UserType, "Owner of this post" do
13 | resolve ->(post, args, ctx) {
14 | RecordLoader.for(User).load(post.user_id)
15 | }
16 | end
17 |
18 | field :comments do
19 | type !types[!CommentType]
20 | description "All comments association with this post."
21 | resolve ->(post, args, ctx){
22 | post.comments.order(created_at: :desc)
23 | }
24 | end
25 | end
26 |
--------------------------------------------------------------------------------
/app/graph/types/query_type.rb:
--------------------------------------------------------------------------------
1 | QueryType = GraphQL::ObjectType.define do
2 | name "Query"
3 | description "The query root of this schema. See available queries."
4 |
5 | field :posts do
6 | type types[PostType]
7 | description 'Fetch paginated posts collection'
8 | argument :offset, types.Int, default_value: 0
9 | argument :keywords, types.String, default_value: nil
10 | resolve ->(object, args, ctx) {
11 | Post
12 | .search(args[:keywords])
13 | .paginate(args[:offset])
14 | .order(created_at: :desc)
15 | }
16 | end
17 |
18 | field :postsCount do
19 | type types.Int
20 | description 'Number of post'
21 | argument :keywords, types.String, default_value: nil
22 | resolve ->(object, args, ctx) {
23 | Post.search(args[:keywords]).count
24 | }
25 | end
26 |
27 | field :post, PostType do
28 | argument :id, types.ID
29 | description 'fetch a Post by id'
30 | resolve ->(object, args, ctx){
31 | Post.find(args[:id])
32 | }
33 | end
34 |
35 | field :currentUser, UserType do
36 | description 'fetch the current user.'
37 | resolve ->(object, args, ctx){
38 | ctx[:current_user]
39 | }
40 | end
41 | end
42 |
--------------------------------------------------------------------------------
/app/graph/types/user_type.rb:
--------------------------------------------------------------------------------
1 | UserType = GraphQL::ObjectType.define do
2 | name "User"
3 | description "An user entry, returns basic user information"
4 |
5 | field :id, !types.ID
6 | field :name, types.String, "The name of this user"
7 | field :email, types.String, "The email of this user"
8 | field :created_at, types.String, "The date this user created an account"
9 | field :token, types.String, "Access token" do
10 | resolve ->(user, args, ctx) {
11 | user.access_token
12 | }
13 | end
14 | end
15 |
--------------------------------------------------------------------------------
/app/graph/utils/auth.rb:
--------------------------------------------------------------------------------
1 | module Auth
2 | def self.protect(resolve)
3 | ->(obj, args, ctx) do
4 | if ctx[:current_user]
5 | resolve.call(obj, args, ctx)
6 | else
7 | FieldError.error("You need to sign in or sign up before continuing")
8 | end
9 | end
10 | end
11 | end
12 |
--------------------------------------------------------------------------------
/app/graph/utils/concurrent_batch_setup.rb:
--------------------------------------------------------------------------------
1 | module ConcurrentBatchSetup
2 | module_function
3 |
4 | def before_query(query)
5 | # Use the same executor for batch queries
6 | GraphQL::Batch::Executor.current ||= GraphQL::Batch::Executor.new
7 | end
8 |
9 | def after_query(query)
10 | GraphQL::Batch::Executor.current = nil
11 | end
12 | end
--------------------------------------------------------------------------------
/app/graph/utils/record_loader.rb:
--------------------------------------------------------------------------------
1 | class RecordLoader < GraphQL::Batch::Loader
2 | def initialize(model)
3 | @model = model
4 | end
5 |
6 | def perform(ids)
7 | @model.where(id: ids).each { |record| fulfill(record.id, record) }
8 | ids.each { |id| fulfill(id, nil) unless fulfilled?(id) }
9 | end
10 | end
11 |
--------------------------------------------------------------------------------
/app/mailers/application_mailer.rb:
--------------------------------------------------------------------------------
1 | class ApplicationMailer < ActionMailer::Base
2 | default from: 'from@example.com'
3 | layout 'mailer'
4 | end
5 |
--------------------------------------------------------------------------------
/app/models/application_record.rb:
--------------------------------------------------------------------------------
1 | class ApplicationRecord < ActiveRecord::Base
2 | self.abstract_class = true
3 |
4 | def fields_errors
5 | field_errors = []
6 | self.errors.each do |attr, msg|
7 | field_errors.push(FieldError.new(attr.to_s, msg))
8 | end
9 | field_errors
10 | end
11 | end
12 |
--------------------------------------------------------------------------------
/app/models/comment.rb:
--------------------------------------------------------------------------------
1 | class Comment < ApplicationRecord
2 |
3 | validates :content, presence: true
4 |
5 | belongs_to :user, optional: false
6 | belongs_to :post, touch: true, counter_cache: true
7 | end
8 |
--------------------------------------------------------------------------------
/app/models/concerns/trackable.rb:
--------------------------------------------------------------------------------
1 | module Trackable
2 | def update_tracked_fields(request)
3 | old_current, new_current = self.current_sign_in_at, Time.now.utc
4 | self.last_sign_in_at = old_current || new_current
5 | self.current_sign_in_at = new_current
6 |
7 | old_current, new_current = self.current_sign_in_ip, request.remote_ip
8 | self.last_sign_in_ip = old_current || new_current
9 | self.current_sign_in_ip = new_current
10 |
11 | self.sign_in_count ||= 0
12 | self.sign_in_count += 1
13 | self.save!
14 | end
15 | end
--------------------------------------------------------------------------------
/app/models/field_error.rb:
--------------------------------------------------------------------------------
1 | class FieldError < Struct.new(:field, :message)
2 | def self.error(msg)
3 | {messages: [FieldError.new("base", msg)]}
4 | end
5 | end
6 |
--------------------------------------------------------------------------------
/app/models/post.rb:
--------------------------------------------------------------------------------
1 | class Post < ApplicationRecord
2 |
3 | validates :title, :content, presence: true
4 | validates :title, length: { minimum: 3 }
5 | cattr_accessor(:paginates_per) { 10 }
6 |
7 | has_many :comments, dependent: :destroy
8 | belongs_to :user
9 |
10 | def self.paginate(offset)
11 | offset(offset).limit(self.paginates_per)
12 | end
13 |
14 | def self.search(keywords)
15 | return self if keywords.blank?
16 | where('lower(title) like :keywords OR lower(content) like :keywords', :keywords => "%#{keywords.downcase}%")
17 | end
18 |
19 | def description
20 | self.content.truncate(180)
21 | end
22 | end
23 |
--------------------------------------------------------------------------------
/app/models/user.rb:
--------------------------------------------------------------------------------
1 | class User < ApplicationRecord
2 | include Trackable
3 | has_secure_password
4 |
5 | validates :name, :email, :password_digest, presence: true
6 | validates :email, uniqueness: true, format: /@/
7 | validates :password, length: { minimum: 6 }, allow_blank: true
8 |
9 | has_many :posts, dependent: :destroy
10 | has_many :comments, dependent: :destroy
11 |
12 | def generate_access_token!
13 | self.access_token = Digest::SHA1.hexdigest("#{Time.now}-#{self.id}-#{SecureRandom.hex}")
14 | self.save!
15 | self.access_token
16 | end
17 |
18 | def update_with_password(password: nil, password_confirmation: nil, current_password: nil)
19 | if self.authenticate(current_password)
20 | self.errors.add(:base, "Password can't be blank") && (return false) if password.blank?
21 | self.update(password: password, password_confirmation: password_confirmation)
22 | else
23 | self.errors.add(:current_password, "Invalid password")
24 | return false
25 | end
26 | end
27 | end
28 |
--------------------------------------------------------------------------------
/bin/bundle:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env ruby
2 | ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
3 | load Gem.bin_path('bundler', 'bundle')
4 |
--------------------------------------------------------------------------------
/bin/rails:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env ruby
2 | APP_PATH = File.expand_path('../config/application', __dir__)
3 | require_relative '../config/boot'
4 | require 'rails/commands'
5 |
--------------------------------------------------------------------------------
/bin/rake:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env ruby
2 | require_relative '../config/boot'
3 | require 'rake'
4 | Rake.application.run
5 |
--------------------------------------------------------------------------------
/bin/setup:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env ruby
2 | require 'pathname'
3 | require 'fileutils'
4 | include FileUtils
5 |
6 | # path to your application root.
7 | APP_ROOT = Pathname.new File.expand_path('../../', __FILE__)
8 |
9 | def system!(*args)
10 | system(*args) || abort("\n== Command #{args} failed ==")
11 | end
12 |
13 | chdir APP_ROOT do
14 | # This script is a starting point to setup your application.
15 | # Add necessary setup steps to this file.
16 |
17 | puts '== Installing dependencies =='
18 | system! 'gem install bundler --conservative'
19 | system('bundle check') || system!('bundle install')
20 |
21 | # Install JavaScript dependencies if using Yarn
22 | # system('bin/yarn')
23 |
24 |
25 | # puts "\n== Copying sample files =="
26 | # unless File.exist?('config/database.yml')
27 | # cp 'config/database.yml.sample', 'config/database.yml'
28 | # end
29 |
30 | puts "\n== Preparing database =="
31 | system! 'bin/rails db:setup'
32 |
33 | puts "\n== Removing old logs and tempfiles =="
34 | system! 'bin/rails log:clear tmp:clear'
35 |
36 | puts "\n== Restarting application server =="
37 | system! 'bin/rails restart'
38 | end
39 |
--------------------------------------------------------------------------------
/bin/spring:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env ruby
2 |
3 | # This file loads spring without using Bundler, in order to be fast.
4 | # It gets overwritten when you run the `spring binstub` command.
5 |
6 | unless defined?(Spring)
7 | require 'rubygems'
8 | require 'bundler'
9 |
10 | lockfile = Bundler::LockfileParser.new(Bundler.default_lockfile.read)
11 | if spring = lockfile.specs.detect { |spec| spec.name == "spring" }
12 | Gem.use_paths Gem.dir, Bundler.bundle_path.to_s, *Gem.path
13 | gem 'spring', spring.version
14 | require 'spring/binstub'
15 | end
16 | end
17 |
--------------------------------------------------------------------------------
/bin/update:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env ruby
2 | require 'pathname'
3 | require 'fileutils'
4 | include FileUtils
5 |
6 | # path to your application root.
7 | APP_ROOT = Pathname.new File.expand_path('../../', __FILE__)
8 |
9 | def system!(*args)
10 | system(*args) || abort("\n== Command #{args} failed ==")
11 | end
12 |
13 | chdir APP_ROOT do
14 | # This script is a way to update your development environment automatically.
15 | # Add necessary update steps to this file.
16 |
17 | puts '== Installing dependencies =='
18 | system! 'gem install bundler --conservative'
19 | system('bundle check') || system!('bundle install')
20 |
21 | puts "\n== Updating database =="
22 | system! 'bin/rails db:migrate'
23 |
24 | puts "\n== Removing old logs and tempfiles =="
25 | system! 'bin/rails log:clear tmp:clear'
26 |
27 | puts "\n== Restarting application server =="
28 | system! 'bin/rails restart'
29 | end
30 |
--------------------------------------------------------------------------------
/bin/yarn:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env ruby
2 | VENDOR_PATH = File.expand_path('..', __dir__)
3 | Dir.chdir(VENDOR_PATH) do
4 | begin
5 | exec "yarnpkg #{ARGV.join(" ")}"
6 | rescue Errno::ENOENT
7 | $stderr.puts "Yarn executable was not detected in the system."
8 | $stderr.puts "Download Yarn at https://yarnpkg.com/en/docs/install"
9 | exit 1
10 | end
11 | end
12 |
--------------------------------------------------------------------------------
/client/.env:
--------------------------------------------------------------------------------
1 | NODE_PATH=src
2 | PUBLIC_URL=/
3 | PORT=8080
4 | BROWSER=none
5 | REACT_EDITOR=code
--------------------------------------------------------------------------------
/client/.gitignore:
--------------------------------------------------------------------------------
1 | # See https://help.github.com/ignore-files/ for more about ignoring files.
2 |
3 | # dependencies
4 | /node_modules
5 |
6 | # testing
7 | /coverage
8 |
9 | # production
10 | /build
11 |
12 | # misc
13 | .DS_Store
14 | .env.local
15 | .env.development.local
16 | .env.test.local
17 | .env.production.local
18 |
19 | npm-debug.log*
20 | yarn-debug.log*
21 | yarn-error.log*
22 | schema.json
--------------------------------------------------------------------------------
/client/config-overrides.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 | const CompressionPlugin = require('compression-webpack-plugin');
3 | const { getLoader } = require('react-app-rewired');
4 |
5 | function rewireGraphQLTag(config, env) {
6 | const gqlExtension = /\.(graphql|gql)$/;
7 |
8 | // Exclude .graphql files from the file-loader
9 | const fileLoader = getLoader(
10 | config.module.rules,
11 | rule =>
12 | rule.loader && typeof rule.loader === 'string' && rule.loader.indexOf(`${path.sep}file-loader${path.sep}`) !== -1
13 | );
14 | fileLoader.exclude.push(gqlExtension);
15 |
16 | // Add loader for graphQL files
17 | const graphQLRule = {
18 | test: gqlExtension,
19 | loader: 'graphql-tag/loader',
20 | exclude: /node_modules/
21 | };
22 | config.module.rules.push(graphQLRule);
23 | config.resolve.extensions.push('.graphql');
24 |
25 | return config;
26 | }
27 |
28 | module.exports = function override(config, env) {
29 | config.resolve.extensions.push('.ts', '.tsx');
30 | coconfignf = rewireGraphQLTag(config, env);
31 | config.plugins.push(
32 | new CompressionPlugin({
33 | algorithm: 'gzip'
34 | })
35 | );
36 |
37 | return config;
38 | };
39 |
--------------------------------------------------------------------------------
/client/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "graphql-rails-blog",
3 | "version": "1.0.0",
4 | "description": "Blog App build with Rails 5, React and GraphQL",
5 | "homepage": "https://github.com/MatthieuSegret/graphql-rails-blog",
6 | "engines": {
7 | "node": "9.2.0",
8 | "npm": "5.5.1"
9 | },
10 | "author": "Matthieu Segret