active_graphql 0.2.1

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/docs/README.md

@@ -0,0 +1,95 @@
+# ActiveGraphql
+[![Build Status](https://travis-ci.com/samesystem/active_graphql.svg?branch=master)](https://travis-ci.com/samesystem/active_graphql)
+[![codecov](https://codecov.io/gh/samesystem/active_graphql/branch/master/graph/badge.svg)](https://codecov.io/gh/samesystem/active_graphql)
+[![Documentation](https://readthedocs.org/projects/ansicolortags/badge/?version=latest)](https://samesystem.github.io/active_graphql)
+
+GraphQL client which allows to interact with graphql using ActiveRecord-like API
+
+Detailed documentation can be found at https://samesystem.github.io/active_graphql	
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_graphql'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_graphql
+
+## Usage
+
+You can fetch data from GraphQL in two different ways: using `ActiveGraphql::Client` or using `ActiveGraphql::Model`
+
+### [ActiveGraphql::Client](client.md)
+
+`ActiveGraphql::Client` is a client which allows you to make requests using ruby-friendly code:
+
+```ruby
+client = ActiveGraphql::Client.new(url: 'https://example.com/graphql')
+
+client.query(:findUser).inputs(id: 1).outputs(:name, :avatar_url).result
+# or same request with AR-style syntax
+client.query(:findUser).select(:name, :avatar_url).where(id: 1).result
+```
+
+Find out more how to use Client in [Client documentation](client.md)
+
+### [ActiveGraphql::Model](model.md)
+
+If you have well structured GraphQL endpoint, which has CRUD actions for each entity then you can interact with GraphQL endpoints using `ActiveGraphql::Model`.
+It allows you to have separate class for separate GraphQL entity, Here is an example:
+
+Suppose you have following endpoints in graphql:
+
+* `users(filter: UsersFilter!`) - index action with filtering possibilities
+* `user(id: ID!)` - show action
+
+In this case you can create ruby class like this:
+
+```ruby
+class User
+  include ActiveGraphql::Model
+
+  active_graphql do |c|
+    c.url('http://example.com/graphql')
+    c.attributes :id, :first_name, :last_name, :created_at
+  end
+end
+```
+
+with this small setup you are able to do following:
+
+```ruby
+User.where(first_name: 'John').to_a # list all users with name "John"
+User.limit(5).to_a # list first 5 users
+User.find(1) # find user with ID: 1
+User.first(2) # find first 2 users
+User.last(3) # find last 3 users
+```
+
+Find out more how to use Model in [Model documentation](client.md)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/samesystem/active_graphql. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the ActiveGraphql project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/samesystem/active_graphql/blob/master/CODE_OF_CONDUCT.md).

data/docs/_sidebar.md

@@ -0,0 +1,4 @@
+* [Home](README)
+* [Client](client.md)
+* [Model](model.md)
+

data/docs/client.md

@@ -0,0 +1,69 @@
+# Client
+
+## Initialization
+
+to initialize graphql client, simply create new client instance with url:
+
+```ruby
+client = ActiveGraphql::Client.new(url: 'http://example.com/graphql')
+```
+
+you can also provide extra options which will be accepted by addapter, like this:
+
+```ruby
+client = ActiveGraphql::Client.new(url: 'http://example.com/graphql', headers: {}, schema_path: '...')
+```
+
+## query and mutation actions
+
+```ruby
+mutation = client.mutation(:create_user)
+query = client.query(:find_user)
+```
+
+### where (alias: input)
+
+In order to filter values you can query with `where` method:
+
+```ruby
+query = query.where(name: 'John', date: { from: '2000-01-01' })
+```
+
+this will produce following GraphQL:
+
+```graphql
+query {
+  find_user(name: "John", date: { from: "2000-01-01" }) {
+    ...
+  }
+}
+```
+
+### select (alias: output)
+
+In order to select which attributes you want to receive from query then you need to use `select` method:
+
+```ruby
+query = query.select(:name, date: [:year])
+```
+
+this will produce following GraphQL:
+
+```graphql
+query {
+  find_user {
+    name
+    date { year }
+  }
+}
+```
+
+### meta
+
+You can assign meta attributes in order to use them later
+
+```ruby
+query = query.meta(custom: true)
+query = query.meta(also_custom: 'yes')
+query.meta_attributes # => { :custom => true, :also_custom => "yes" }
+```

data/docs/index.html

@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Document</title>
+  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" />
+  <meta name="description" content="Description">
+  <meta name="viewport" content="width=device-width, user-scalable=no, initial-scale=1.0, maximum-scale=1.0, minimum-scale=1.0">
+  <link rel="stylesheet" href="https://unpkg.com/docsify/lib/themes/vue.css">
+</head>
+<body>
+  <div id="app"></div>
+  <script>
+    function parseQueryString (queryString) {
+      var params = {};
+      var temp;
+      // Split into key/value pairs
+      queries = queryString.split("&");
+      // Convert the array of strings into an object
+      for (var i = 0, l = queries.length; i < l; i++ ) {
+        temp = queries[i].split('=');
+        params[temp[0]] = temp[1];
+      }
+      return params;
+    };
+
+    function getJsonFromUrl() {
+      return parseQueryString(location.search.substr(1));
+    }
+
+    window.$docsify = {
+      auto2top: true,
+      name: 'ActiveGraphql',
+      repo: 'https://github.com/samesystem/active_graphql',
+      subMaxLevel: 3,
+      loadSidebar: true,
+      formatUpdated: '{MM}/{DD} {HH}:{mm}',
+      branchBasePath: 'https://raw.githubusercontent.com/samesystem/active_graphql/',
+      plugins: [
+        function (hook, vm) { // reasign any config value by param attribute
+          Object.assign(window.$docsify, getJsonFromUrl());
+        },
+
+        function (hook, vm) { // allow to change branch
+          if (!window.$docsify.branchBasePath || !window.$docsify.branch) {
+            return;
+          }
+
+          var branch = window.$docsify.branch;
+          var basePath = window.$docsify.branchBasePath + branch;
+          window.$docsify.basePath = basePath;
+        },
+
+        function (hook, vm) { // add edit page link
+          hook.beforeEach(function (html) {
+            var branch = window.$docsify.branch || 'master'
+            var url = 'https://github.com/samesystem/active_graphql/edit/' + branch + '/docs/' + vm.route.file
+            var editHtml = '[:memo: Edit Document](' + url + ')\n'
+            return html
+              + '\n\n----\n\n'
+              + editHtml
+          })
+        }
+      ]
+    }
+  </script>
+  <script src="https://unpkg.com/docsify/lib/docsify.js"></script>
+  <script src="https://unpkg.com/docsify/lib/plugins/search.min.js"></script>
+</body>
+</html>

data/docs/model.md

@@ -0,0 +1,464 @@
+# Model
+
+## Setup
+
+To create graphql model, you need to include `ActiveGraphql::Model` module in your ruby class like this:
+
+```ruby
+class User
+  include ActiveGraphql::Model
+
+  active_graphql do |c|
+    c.url 'http://localhost:3000'
+    c.attributes :id, :first_name, :last_name
+  end
+end
+```
+
+Attributes also can be nested, like this:
+
+```ruby
+class User
+  include ActiveGraphql::Model
+
+  active_graphql do |c|
+    c.attributes location: [:city, :country, :street]
+  end
+end
+
+User.find(3).location # { city: 'London', country: ... }
+```
+
+### active_graphql.url
+
+Sets url where all GraphQL queries should go
+
+```ruby
+class User
+  include ActiveGraphql::Model
+
+  active_graphql do |c|
+    c.url 'http://localhost:3000'
+  end
+end
+```
+
+### active_graphql.attributes
+
+Sets attributes which can be fetched from graphql
+
+```ruby
+class User
+  include ActiveGraphql::Model
+
+  active_graphql do |c|
+    c.attributes :id, :first_name, :last_name
+  end
+end
+
+User.find(3).first_name # => some name returned from graphql
+```
+
+### active_graphql.attribute
+
+Sets attribute which can be fetched from graphql
+
+```ruby
+class User
+  include ActiveGraphql::Model
+
+  active_graphql do |c|
+    c.attribute :name
+  end
+end
+
+User.find(3).name # => "John"
+```
+
+#### nested attributes
+
+You can have nested attributes. Nested values will be returned as hash:
+
+```ruby
+class User
+  include ActiveGraphql::Model
+
+  active_graphql do |c|
+    c.attribute :id
+    c.attribute :location, [:lat, :long]
+  end
+end
+
+User.find(3).location #=> { lat: 25.0, long: 26.0 }
+```
+
+#### decorated attributes
+
+You can use decorator methods in order to modify model attribute values. It's very in combination with nested values
+
+```ruby
+class User
+  include ActiveGraphql::Model
+
+  active_graphql do |c|
+    c.attribute :name, decorate_with: :make_fancy_name
+  end
+
+  def make_fancy_name(original_name)
+    "Mr. #{original_name}"
+  end
+end
+
+User.find(3).name #=> "Mr. John"
+```
+
+### active_graphql.resource_name
+
+Sets attributes which can be fetched from graphql
+
+```ruby
+class User
+  include ActiveGraphql::Model
+
+  active_graphql do |c|
+    c.resource_name :admin_user
+    c.attributes :id
+  end
+end
+
+User.where(name: 'John').to_graphql # => "query { adminUsers(name: "John") { id } }"
+```
+
+### active_graphql.primary_key
+
+By default primary key is `id`, but you can change it like this:
+
+```ruby
+class User
+  include ActiveGraphql::Model
+
+  active_graphql do |c|
+    c.primary_key :email
+  end
+end
+
+User.find('john@example.com') # will execute in GraphQL: 'query { user(email: "john@example.com") }'
+```
+
+## Methods
+
+### find
+
+Use `find` method in order to find record:
+
+```ruby
+user = User.find(5)
+```
+
+### update
+
+Use `update` to update record on graphql side:
+
+```ruby
+User.find(5).update(first_name: 'John') # => true or false
+```
+
+### update!
+
+Use `update!` to update record on graphql side:
+
+```ruby
+User.find(5).update!(first_name: 'John') # => true or exception
+```
+
+### destroy
+
+Use `destroy` in order to delete record on graphql side:
+
+```ruby
+User.find(5).destroy # => true or false
+```
+
+### create
+
+to create model on graphql side simply use `create` method, like this:
+
+```ruby
+user = User.create(first_name: 'John', last_name: 'Doe')
+```
+
+### create!
+
+as in ActiveRecord, there is `create!` method which will raise error when create fails:
+
+```ruby
+user = User.create!(first_name: 'John', last_name: 'Doe')
+```
+
+### where
+
+Use `where` method in order to find multiple record:
+
+```ruby
+users = User.where(name: 'John')
+```
+
+### merge
+
+Use `merge` method in order to merge multiple queries:
+
+```ruby
+# same as User.where(name: 'John', surname: 'Doe') :
+users = User.where(name: 'John').merge(User.where(surname: 'Doe'))
+```
+
+### or
+
+Use `or` method in order to query using "or" predicate:
+
+```ruby
+# same as User.where(or: { name: 'John', surname: 'Doe' }) :
+users = User.where(name: 'John').or(User.where(surname: 'Doe'))
+```
+
+Keep in mind that your endpoint must support filtering by "or" key like this:
+
+```graphql
+  query {
+    users(filter: { or: { name: 'John', surname: 'Doe' } }) {
+      ...
+    }
+  }
+```
+
+### order
+
+Use `order` when you need to sort results:
+
+```ruby
+users.order(created_at: :desc)
+```
+
+### find_each
+
+In order to iterate through multiple pages, you need to use `find_each` method
+
+```ruby
+User.all.find_each do |user|
+  do_something(user)
+end
+```
+
+### paginate
+
+you can also paginate records:
+
+```ruby
+User.paginate(page: 1, per_page: 3)
+```
+
+### page
+
+you can also paginate records:
+
+```ruby
+User.page(1)
+```
+
+### Selecting certain fields
+
+You can select only attributes which you want to be selected from model, like this:
+
+```ruby
+class User
+  include ActiveGraphql::Model
+
+  active_graphql do |c|
+    c.url 'http://example.com/graphql'
+    c.attributes :id, :first_name, location: %i[street city], name: :full_name
+  end
+
+  def self.main_data
+    select(:first_name, location: :city, name: :full_name)
+  end
+end
+
+User.main_data
+```
+
+This will produce GraphQL:
+```graphql
+query {
+  users {
+    firstName
+    location {
+      city
+    }
+    name {
+      fullName
+    }
+  }
+}
+```
+
+### defining custom queries
+
+You can define your custom queries by adding class method, like this:
+
+```ruby
+class User
+  include ActiveGraphql::Model
+
+  active_graphql do |c|
+    c.attributes :id
+  end
+
+  def self.with_custom
+    where(custom: true)
+  end
+end
+
+User.where(id: 1).with_custom
+```
+
+this will produce GraphQL:
+
+```graphql
+query {
+  users(filter: { id: 1, custom: true } ) {
+    id
+  }
+}
+```
+
+### mutate
+
+You can define your custom mutations by adding instance method, like this:
+
+```ruby
+class User
+  include ActiveGraphql::Model
+
+  active_graphql do |c|
+    c.attributes :id, :first_name, :last_name
+  end
+
+  def update_name(first_name, last_name)
+    mutate(:update_name, input: { first_name: 'Fancy', last_name: 'Pants' })
+  end
+end
+
+User.last.update_name('Fancy', 'Pants')
+```
+
+This will produce GraphQL:
+```graphql
+mutation {
+  updateName(id: 99, input: { firstName: 'Fancy', lastName: 'Pants' }) {
+    id
+    firstName
+    lastName
+    ...
+  }
+}
+```
+
+## Requirements for GraphQL server side
+
+In order to make active_graphql work, server must met some conditions.
+
+### Naming requirements
+
+Resource, attribute and field names must be in camelcase
+
+#### Resource name requirements for CRUD actions
+
+Let's say we have `BlogPost` resource, so CRUD actions should be named like this:
+- `blogPost(id: ID!)` (aka, `show` action)
+- `blogPosts(filter: FilterInput)` (aka, `index` action)
+- `createBlogPost(input: SomeCreateInput!)` (aka, `create` action)
+- `updateBlogPost(id: ID!, input: SomeUpdateInput!)` (aka, `update` action)
+- `destroyBlogPost(id: ID!)` (aka, `destroy` action)
+
+### Requirements for Model#find methods
+
+In order to make Model#find work, server must have resource in singular form with single `id: ID!` argument.
+
+Example: `user(id: ID!)`
+
+### Requirements for Model#all, Model#find_each methods
+
+In order to make Model#all and Model#find_each work, server must have resource in plural form and also response should be paginated.
+
+Example:
+```
+users(first: Integer, last: Integer, before: String, after: String) {
+  edges {
+    node {
+      ...
+    }
+  }
+}
+```
+
+### Requirements for Model#where, Model#find_by methods
+
+In order to make Model#where and Model#find_by work, server must have resource in plural form with `filter: SomeFilterInput` argument. Also resource must match requirements for Model#all too (see previous section)
+
+Example:
+```
+type UsersFilterInput {
+  firstName: String!
+  lastName: String!
+}
+
+users(filter: UserFilterInput) {
+  edges {
+    node {
+      ...
+    }
+  }
+}
+```
+
+### Requirements for Model#or method
+
+In order to make Model#or resouce must match requirements for `Model#where` method. Also `filter` input must have `or` argument
+
+Example:
+```
+type UsersFilterInput {
+  or: UsersOrFilterInput
+  groupId: [ID!],
+  name: String!
+}
+
+type UsersOrFilterInput {
+  groupId: [ID!],
+  name: String!
+}
+
+users(filter: UserFilterInput) {
+  edges {
+    node {
+      ...
+    }
+  }
+}
+```
+
+### Requirements for Model#count
+
+In order to make Model#where and Model#find_by work, server must have resource in plural form. This resource must have `total:Integer` **output** field:
+
+Example:
+```
+users() {
+  total
+  edges {
+    node {
+      ...
+    }
+  }
+}
+```