shopify_app 6.2.1 → 6.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 24a872186951e1f4c991d937f7f2a30e798f357e
-  data.tar.gz: 38c56b9a5e8255b6b59a425819b3390d5962ad7b
+  metadata.gz: 0b424982cf65b0c9b98ba51dd08c9c6a4ce992c3
+  data.tar.gz: 10e9c18f779eec012ab057afd1c5e2d220900aa3
 SHA512:
-  metadata.gz: a2ccfb1a9ef061db062030078ee3015d9e832abedf8ba01a65eb826dc3a51c7f2f47787b3cf822c2bb4ac31b08b4c6dbc2ee2615981631d30459a7aff9cbe615
-  data.tar.gz: 1b7dee2021821fe6182b747b6392ae9887d746f33c86c8b41b292d3e4b041220c225d86c7df54c4ec48194e139c998d5f93548bbac26304f118b84ac8fbda889
+  metadata.gz: 439c8119016ab19b45dee3dcab077626438cea6d7c16c151e5c06cf441a7d3131e8660c29939f4e303a164412b7dbe048e8ba8bf43e77e6e851ebc0f0ad186ea
+  data.tar.gz: cbfdb0d91cdd3af92b08bff988f1389f85ac348e923a63c8d43d7e98007835593b432d6240dcf4248de6ce9d05fa65e42623ca9b9b3559ca1560f58903b0bbe7

data/CHANGELOG

@@ -1,3 +1,15 @@
+6.3.0
+-----
+
+* Move SessionStorage from a generated class to a re-usable module. To
+  migrate to the new module, delete the old generated SessionStorage class
+  in the models directory and include the SessionStorage module in your Shop model.
+* Adds a WebhooksManager class and allows you to configure what webhooks your app
+  needs. The rest is taken care of by ShopifyApp provided you set up a backgroud queue
+  with ActiveJob
+* Adds a WebhooksController module which can be included to handle the boiler plate code
+  for a controller receiving webhooks from Shopify
+
 6.2.1
 -----
 

data/CONTRIBUTING.md

@@ -0,0 +1,14 @@
+Submitting Issues
+-----------------
+
+Please open an issue here if you encounter a specific bug with this gem or the generators
+
+General questions about the Shopify API should be posted on the [Shopify forums](https://ecommerce.shopify.com/c/shopify-apis-and-technology).
+
+
+Authentication Issues
+---------------------
+
+A great deal of the issues surrounding this repo are around authenticating the generated app with Shopify. 
+
+If you are experiencing issues with your app authenticating the best way to get help fast is to create a repo with the minimal amount of code to demonstrate the issue and a clearly documented set of steps you took to arrive there. This will help us solve your problem quicker since we won't need to spend any time figuring out how to reproduce the bug.

data/README.md

@@ -25,10 +25,20 @@ If you don't have a Shopify Partner account yet head over to http://shopify.com/
 
 Once you have a Partner account create a new application to get an Api key and other Api credentials. To create a development application set the Application Callback URL to
 
-	http://localhost:3000/login
+```
+http://localhost:3000/login
+```
+
+and the `redirect_uri` to
+
+```
+http://localhost:3000/auth/shopify/callback
+```
 
 This way you'll be able to run the app on your local machine.
 
+Also note, ShopifyApp creates embedded apps by default, so remember to check `enabled` for the embedded settings.
+
 
 Installation
 ------------
@@ -108,50 +118,44 @@ ShopifyApp.configure do |config|
 end
 ```
 
-ShopifyApp::SessionRepository
------------------------------
 
-`ShopifyApp::SessionRepository` allows you as a developer to define how your sessions are retrieved and
-stored for a shop. This can simply be your `Shop` model that stores the API Token and shop name. If
-you are using ActiveRecord, then all you need to implement is `self.store(shopify_session)` and
-`self.retrieve(id)` in order to store the record on disk or retrieve it for use at a later point.
-It is imperative that your store method returns the identifier for the session. Typically this is
-just the record ID.
+WebhooksManager
+---------------
 
-Your ActiveRecord model would look something like this:
+ShopifyApp can manage your app's webhooks for you (requires ActiveJob). Set which webhooks you require in the initializer:
 
 ```ruby
-class Shop < ActiveRecord::Base
-  def self.store(session)
-    shop = self.new(domain: session.url, token: session.token)
-    shop.save!
-    shop.id
-  end
-
-  def self.retrieve(id)
-    if shop = self.where(id: id).first
-      ShopifyAPI::Session.new(shop.domain, shop.token)
-    end
-  end
+ShopifyApp.configure do |config|
+  config.webhooks = [
+    {topic: 'carts/update', address: 'example-app.com/webhooks'}
+  ]
 end
 ```
 
-By default you will have an in memory store but it **won't work** on multi-server environments since
-they won't be sharing the static data that would be required in case your user gets directed to a
-different server by your load balancer.
-
-The in memory store also does not behave well on Heroku because the session data would be destroyed
-when a dyno is killed due to inactivity.
+When the oauth callback is completed successfully ShopifyApp will queue a background job which will ensure all the specified webhooks exist for that shop. Because this runs on every oauth callback it means your app will always have the webhooks it needs even if the user uninstalls and re-installs the app.
 
-Changing the `ShopifyApp::SessionRepository.storage` can simply be done by editing
-`config/initializers/shopify_session_repository.rb` to use the correct model.
+There is also a WebhooksController module that you can include in a controller that receives Shopify webhooks. For example:
 
 ```ruby
-ShopifyApp::SessionRepository.storage = 'Shop'
+class WebhooksController < ApplicationController
+  include ShopifyApp::WebhooksController
+
+  def carts_update
+    SomeJob.perform_later(shopify_domain: shop_domain)
+    head :ok
+  end
+end
 ```
 
-If you run the `shop_model` generator it will create the required code to use the generated Shop model as the SessionRepository and update the initializer.
+The module skips the `verify_authenticity_token` before_action and adds an action to verify that the webhook came from Shopify.
+
 
+ShopifyApp::SessionRepository
+-----------------------------
+
+`ShopifyApp::SessionRepository` allows you as a developer to define how your sessions are retrieved and stored for a shop. The `SessionRepository` is configured using the `config/initializers/shopify_session_repository.rb` file and can be set to any object the implements `self.store(shopify_session)` which stores the session and returns a unique identifier and `self.retrieve(id)` which returns a `ShopifyAPI::Session` for the passed id. See either the `InMemorySessionStore` or the `SessionStorage` module for examples.
+
+If you only run the install generator then by default you will have an in memory store but it **won't work** on multi-server environments including Heroku. If you ran all the generators including the shop_model generator then the Shop model itself will be the `SessionRepository`. If you look at the implementation of the generated shop model you'll see that this gem provides an activerecord mixin for the `SessionRepository`. You can use this mixin on any model that responds to `shopify_domain` and `shopify_token`.
 
 AuthenticatedController
 -----------------------
@@ -164,9 +168,11 @@ Troubleshooting
 ### Generator shopify_app:install hangs
 
 Rails uses spring by default to speed up development. To run the generator, spring has to be stopped:
+
 ```sh
 $ bundle exec spring stop
 ```
+
 Run shopify_app generator again.
 
 

data/RELEASING

@@ -10,7 +10,4 @@ Releasing ShopifyApp
   $ git push
 7. Push out the tags
   $ git push --tags
-8. Build the new .gem from the updated .gemspec
-  $ gem build shopify_app.gemspec
-9. Publish the Gem to gemcutter
-  $ gem push shopify_app-X.Y.Z.gem
+8. Use Shipit to build and push the gem

data/lib/generators/shopify_app/install/install_generator.rb

@@ -63,6 +63,7 @@ module ShopifyApp
       def create_embedded_app_layout
         if embedded_app?
           copy_file 'embedded_app.html.erb', 'app/views/layouts/embedded_app.html.erb'
+          copy_file '_flash_messages.html.erb', 'app/views/layouts/_flash_messages.html.erb'
         end
       end
 

data/lib/generators/shopify_app/install/templates/_flash_messages.html.erb

@@ -0,0 +1,13 @@
+<script type="text/javascript">
+  var eventName = typeof(Turbolinks) !== 'undefined' ? 'page:change' : 'DOMContentLoaded';
+
+  document.addEventListener(eventName, function() {
+    <% if flash[:notice] %>
+      ShopifyApp.flashNotice("<%= j flash[:notice].html_safe %>");
+    <% end %>
+
+    <% if flash[:error] %>
+      ShopifyApp.flashError("<%= j flash[:error].html_safe %>");
+    <% end %>
+  });
+</script>

data/lib/generators/shopify_app/install/templates/embedded_app.html.erb

@@ -19,5 +19,6 @@
 
 <body>
   <%= yield %>
+  <%= render 'layouts/flash_messages' %>
 </body>
 </html>

data/lib/generators/shopify_app/install/templates/shopify_app_ready_script.html

@@ -2,7 +2,7 @@
   ShopifyApp.ready(function(){
     ShopifyApp.Bar.initialize({
       title: "Home",
-      icon: "<%= asset_path('faveicon.png') %>"
+      icon: "<%= asset_path('favicon.ico') %>"
     });
   });
 </script>

data/lib/generators/shopify_app/shop_model/shop_model_generator.rb

@@ -15,14 +15,14 @@ module ShopifyApp
         copy_migration 'create_shops.rb'
       end
 
-      def create_session_storage
-        copy_file 'session_storage.rb', 'app/models/session_storage.rb'
-      end
-
       def create_session_storage_initializer
         copy_file 'shopify_session_repository.rb', 'config/initializers/shopify_session_repository.rb', force: true
       end
 
+      def create_shop_fixtures
+        copy_file 'shops.yml', 'test/fixtures/shops.yml'
+      end
+
       private
 
       def copy_migration(migration_name, config = {})

data/lib/generators/shopify_app/shop_model/templates/shop.rb

@@ -1,3 +1,4 @@
 class Shop < ActiveRecord::Base
   include ShopifyApp::Shop
+  include ShopifyApp::SessionStorage
 end

data/lib/generators/shopify_app/shop_model/templates/shopify_session_repository.rb

@@ -1,7 +1,7 @@
 if Rails.configuration.cache_classes
-  ShopifyApp::SessionRepository.storage = SessionStorage
+  ShopifyApp::SessionRepository.storage = Shop
 else
   ActionDispatch::Reloader.to_prepare do
-    ShopifyApp::SessionRepository.storage = SessionStorage
+    ShopifyApp::SessionRepository.storage = Shop
   end
 end

data/lib/generators/shopify_app/shop_model/templates/shops.yml

@@ -0,0 +1,3 @@
+regular_shop:
+  shopify_domain: 'regular-shop.myshopify.com'
+  shopify_token: 'token'

data/lib/shopify_app.rb

@@ -10,11 +10,17 @@ require 'shopify_app/configuration'
 # engine
 require 'shopify_app/engine'
 
+# jobs
+require 'shopify_app/webhooks_manager_job'
+
 # helpers and concerns
 require 'shopify_app/shop'
+require 'shopify_app/session_storage'
 require 'shopify_app/controller'
 require 'shopify_app/sessions_controller'
 require 'shopify_app/login_protection'
+require 'shopify_app/webhooks_manager'
+require 'shopify_app/webhooks_controller'
 require 'shopify_app/utils'
 
 # session repository

data/lib/shopify_app/configuration.rb

@@ -10,6 +10,7 @@ module ShopifyApp
     attr_accessor :scope
     attr_accessor :embedded_app
     alias_method  :embedded_app?, :embedded_app
+    attr_accessor :webhooks
 
     # configure myshopify domain for local shopify development
     attr_accessor :myshopify_domain
@@ -17,6 +18,10 @@ module ShopifyApp
     def initialize
       @myshopify_domain = 'myshopify.com'
     end
+
+    def has_webhooks?
+      webhooks.present?
+    end
   end
 
   def self.configuration

data/lib/shopify_app/session_storage.rb

@@ -0,0 +1,23 @@
+module ShopifyApp
+  module SessionStorage
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def store(session)
+        shop = self.find_or_initialize_by(shopify_domain: session.url)
+        shop.shopify_token = session.token
+        shop.save!
+        shop.id
+      end
+
+      def retrieve(id)
+        return unless id
+
+        if shop = self.find_by(id: id)
+          ShopifyAPI::Session.new(shop.shopify_domain, shop.shopify_token)
+        end
+      end
+    end
+
+  end
+end

data/lib/shopify_app/sessions_controller.rb

@@ -13,9 +13,14 @@ module ShopifyApp
     def callback
       if response = request.env['omniauth.auth']
         shop_name = response.uid
-        sess = ShopifyAPI::Session.new(shop_name, response['credentials']['token'])
+        token = response['credentials']['token']
+
+        sess = ShopifyAPI::Session.new(shop_name, token)
         session[:shopify] = ShopifyApp::SessionRepository.store(sess)
         session[:shopify_domain] = shop_name
+
+        WebhooksManager.queue(shop_name, token) if ShopifyApp.configuration.has_webhooks?
+
         flash[:notice] = "Logged in"
         redirect_to return_address
       else

data/lib/shopify_app/version.rb

@@ -1,3 +1,3 @@
 module ShopifyApp
-  VERSION = '6.2.1'
+  VERSION = '6.3.0'
 end

data/lib/shopify_app/webhooks_controller.rb

@@ -0,0 +1,35 @@
+module ShopifyApp
+  module WebhooksController
+    extend ActiveSupport::Concern
+
+    included do
+      skip_before_action :verify_authenticity_token
+      before_action :verify_request
+    end
+
+    private
+
+    def verify_request
+      request.body.rewind
+      data = request.body.read
+
+      unless validate_hmac(ShopifyApp.configuration.secret, data)
+        head :unauthorized
+      end
+    end
+
+    def validate_hmac(secret, data)
+      digest  = OpenSSL::Digest.new('sha256')
+      shopify_hmac == Base64.encode64(OpenSSL::HMAC.digest(digest, secret, data)).strip
+    end
+
+    def shop_domain
+      request.headers['HTTP_X_SHOPIFY_SHOP_DOMAIN']
+    end
+
+    def shopify_hmac
+      request.headers['HTTP_X_SHOPIFY_HMAC_SHA256']
+    end
+
+  end
+end

data/lib/shopify_app/webhooks_manager.rb

@@ -0,0 +1,68 @@
+module ShopifyApp
+  class WebhooksManager
+    class CreationFailed < StandardError; end
+
+    def self.queue(shop_name, token)
+      ShopifyApp::WebhooksManagerJob.perform_later(shop_name: shop_name, token: token)
+    end
+
+    def initialize(shop_name, token)
+      @shop_name, @token = shop_name, token
+    end
+
+    def recreate_webhooks!
+      destroy_webhooks
+      create_webhooks
+    end
+
+    def create_webhooks
+      return unless required_webhooks.present?
+
+      with_shopify_session do
+        required_webhooks.each do |webhook|
+          create_webhook(webhook) unless webhook_exists?(webhook[:topic])
+        end
+      end
+    end
+
+    def destroy_webhooks
+      with_shopify_session do
+        ShopifyAPI::Webhook.all.each do |webhook|
+          ShopifyAPI::Webhook.delete(webhook.id) if is_required_webhook?(webhook)
+        end
+      end
+      @current_webhooks = nil
+    end
+
+    private
+
+    def required_webhooks
+      ShopifyApp.configuration.webhooks
+    end
+
+    def is_required_webhook?(webhook)
+      required_webhooks.map{ |w| w[:address] }.include? webhook.address
+    end
+
+    def with_shopify_session
+      ShopifyAPI::Session.temp(@shop_name, @token) do
+        yield
+      end
+    end
+
+    def create_webhook(attributes)
+      attributes.reverse_merge!(format: 'json')
+      webhook = ShopifyAPI::Webhook.create(attributes)
+      raise CreationFailed unless webhook.persisted?
+      webhook
+    end
+
+    def webhook_exists?(topic)
+      current_webhooks[topic]
+    end
+
+    def current_webhooks
+      @current_webhooks ||= ShopifyAPI::Webhook.all.index_by(&:topic)
+    end
+  end
+end

data/lib/shopify_app/webhooks_manager_job.rb

@@ -0,0 +1,11 @@
+module ShopifyApp
+  class WebhooksManagerJob < ActiveJob::Base
+    def perform(params = {})
+      shop_name = params.fetch(:shop_name)
+      token = params.fetch(:token)
+
+      manager = WebhooksManager.new(shop_name, token)
+      manager.create_webhooks
+    end
+  end
+end

data/test/controllers/sessions_controller_test.rb

@@ -76,6 +76,28 @@ class SessionsControllerTest < ActionController::TestCase
     assert_equal 'shop.myshopify.com', session[:shopify_domain]
   end
 
+  test "#callback should start the WebhooksManager if webhooks are configured" do
+    ShopifyApp.configure do |config|
+      config.webhooks = [{topic: 'carts/update', address: 'example-app.com/webhooks'}]
+    end
+
+    ShopifyApp::WebhooksManager.expects(:queue)
+
+    mock_shopify_omniauth
+    get :callback, shop: 'shop'
+  end
+
+  test "#callback doesn't run the WebhooksManager if no webhooks are configured" do
+    ShopifyApp.configure do |config|
+      config.webhooks = []
+    end
+
+    ShopifyApp::WebhooksManager.expects(:queue).never
+
+    mock_shopify_omniauth
+    get :callback, shop: 'shop'
+  end
+
   test "#destroy should clear shopify from session and redirect to login with notice" do
     shop_id = 1
     session[:shopify] = shop_id

data/test/generators/install_generator_test.rb

@@ -73,6 +73,7 @@ class InstallGeneratorTest < Rails::Generators::TestCase
   test "creates the embedded_app layout" do
     run_generator
     assert_file "app/views/layouts/embedded_app.html.erb"
+    assert_file "app/views/layouts/_flash_messages.html.erb"
   end
 
   test "creates the home controller" do

data/test/generators/shop_model_generator_test.rb

@@ -11,6 +11,7 @@ class ShopModelGeneratorTest < Rails::Generators::TestCase
     assert_file "app/models/shop.rb" do |shop|
       assert_match "class Shop < ActiveRecord::Base", shop
       assert_match "include ShopifyApp::Shop", shop
+      assert_match "include ShopifyApp::SessionStorage", shop
     end
   end
 
@@ -21,19 +22,17 @@ class ShopModelGeneratorTest < Rails::Generators::TestCase
     end
   end
 
-  test "adds the session_storage model" do
+  test "adds the shopify_session_repository initializer" do
     run_generator
-    assert_file "app/models/session_storage.rb" do |session_storage|
-      assert_match "class SessionStorage", session_storage
-      assert_match "def self.store(session)", session_storage
-      assert_match " def self.retrieve(id)", session_storage
+    assert_file "config/initializers/shopify_session_repository.rb" do |file|
+      assert_match "ShopifyApp::SessionRepository.storage = Shop", file
     end
   end
 
-  test "adds the shopify_session_repository initializer" do
+  test "creates default shop fixtures" do
     run_generator
-    assert_file "config/initializers/shopify_session_repository.rb" do |file|
-      assert_match "ShopifyApp::SessionRepository.storage = SessionStorage", file
+    assert_file "test/fixtures/shops.yml" do |file|
+      assert_match "regular_shop:", file
     end
   end
 

data/test/shopify_app/configuration_test.rb

@@ -26,4 +26,24 @@ class ConfigurationTest < ActiveSupport::TestCase
     assert_equal "myshopify.io", ShopifyApp.configuration.myshopify_domain
   end
 
+  test "can configure webhooks for creation" do
+    webhook = {topic: 'carts/update', address: 'example-app.com/webhooks', format: 'json'}
+
+    ShopifyApp.configure do |config|
+      config.webhooks = [webhook]
+    end
+
+    assert_equal webhook, ShopifyApp.configuration.webhooks.first
+  end
+
+  test "has_webhooks? is true if webhooks have been configured" do
+    refute ShopifyApp.configuration.has_webhooks?
+
+    ShopifyApp.configure do |config|
+      config.webhooks = [{topic: 'carts/update', address: 'example-app.com/webhooks', format: 'json'}]
+    end
+
+    assert ShopifyApp.configuration.has_webhooks?
+  end
+
 end

data/test/shopify_app/webhooks_controller_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+require 'action_controller'
+require 'action_controller/base'
+
+class WebhooksController < ActionController::Base
+  include ShopifyApp::WebhooksController
+  def carts_update
+    head :ok
+  end
+end
+
+class WebhooksControllerTest < ActionController::TestCase
+  tests WebhooksController
+
+  setup do
+    ShopifyApp::SessionRepository.storage = InMemorySessionStore
+    ShopifyApp.configure do |config|
+      config.secret = 'secret'
+    end
+  end
+
+  test "#carts_update should verify request" do
+    with_application_test_routes do
+      data = {foo: :bar}.to_json
+      @controller.expects(:validate_hmac).with('secret', data.to_s).returns(true)
+      post :carts_update, data
+      assert_response :ok
+    end
+  end
+
+  test "un-verified request returns unauthorized" do
+    with_application_test_routes do
+      data = {foo: :bar}.to_json
+      @controller.expects(:validate_hmac).with('secret', data.to_s).returns(false)
+      post :carts_update, data
+      assert_response :unauthorized
+    end
+  end
+
+  private
+
+  def with_application_test_routes
+    with_routing do |set|
+      set.draw do
+        get '/carts_update' => 'webhooks#carts_update'
+      end
+      yield
+    end
+  end
+end

data/test/shopify_app/webhooks_manager_test.rb

@@ -0,0 +1,86 @@
+require 'test_helper'
+
+class ShopifyApp::WebhooksManagerTest < ActiveSupport::TestCase
+
+  setup do
+    ShopifyApp.configure do |config|
+      config.webhooks = [
+        {topic: 'app/uninstalled', address: "https://example-app.com/webhooks/app_uninstalled"},
+        {topic: 'orders/create', address: "https://example-app.com/webhooks/order_create"},
+        {topic: 'orders/updated', address: "https://example-app.com/webhooks/order_updated"},
+      ]
+    end
+
+    @manager = ShopifyApp::WebhooksManager.new("regular-shop.myshopify.com", "token")
+  end
+
+  test "#create_webhooks makes calls to create webhooks" do
+    ShopifyAPI::Webhook.stubs(all: [])
+
+    expect_webhook_creation('app/uninstalled', "https://example-app.com/webhooks/app_uninstalled")
+    expect_webhook_creation('orders/create', "https://example-app.com/webhooks/order_create")
+    expect_webhook_creation('orders/updated', "https://example-app.com/webhooks/order_updated")
+
+    @manager.create_webhooks
+  end
+
+  test "#create_webhooks when creating a webhook fails, raises an error" do
+    ShopifyAPI::Webhook.stubs(all: [])
+    webhook = stub(persisted?: false)
+    ShopifyAPI::Webhook.stubs(create: webhook)
+
+    assert_raise ShopifyApp::WebhooksManager::CreationFailed do
+      @manager.create_webhooks
+    end
+  end
+
+  test "#create_webhooks when creating a webhook fails and the webhook exists, do not raise an error" do
+    webhook = stub(persisted?: false)
+    webhooks = all_webhook_topics.map{|t| stub(topic: t)}
+    ShopifyAPI::Webhook.stubs(create: webhook, all: webhooks)
+
+    assert_nothing_raised ShopifyApp::WebhooksManager::CreationFailed do
+      @manager.create_webhooks
+    end
+  end
+
+  test "#recreate_webhooks! destroys all webhooks and recreates" do
+    @manager.expects(:destroy_webhooks)
+    @manager.expects(:create_webhooks)
+
+    @manager.recreate_webhooks!
+  end
+
+  test "#destroy_webhooks makes calls to destroy webhooks" do
+    ShopifyAPI::Webhook.stubs(:all).returns(Array.wrap(all_mock_webhooks.first))
+    ShopifyAPI::Webhook.expects(:delete).with(all_mock_webhooks.first.id)
+
+    @manager.destroy_webhooks
+  end
+
+  test "#destroy_webhooks does not destroy webhooks that do not have a matching address" do
+    ShopifyAPI::Webhook.stubs(:all).returns([stub(address: 'http://something-or-the-other.com/webhooks/product_update', id: 7214109)])
+    ShopifyAPI::Webhook.expects(:delete).never
+
+    @manager.destroy_webhooks
+  end
+
+  private
+
+  def expect_webhook_creation(topic, address)
+    stub_webhook = stub(persisted?: true)
+    ShopifyAPI::Webhook.expects(:create).with(topic: topic, address: address, format: 'json').returns(stub_webhook)
+  end
+
+  def all_webhook_topics
+    @webhooks ||= ['app/uninstalled', 'orders/create', 'orders/updated']
+  end
+
+  def all_mock_webhooks
+    [
+      stub(id: 1, address: "https://example-app.com/webhooks/app_uninstalled", topic: 'app/uninstalled'),
+      stub(id: 2, address: "https://example-app.com/webhooks/order_create", topic: 'orders/create'),
+      stub(id: 3, address: "https://example-app.com/webhooks/order_updated", topic: 'orders/updated'),
+    ]
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shopify_app
 version: !ruby/object:Gem::Version
-  version: 6.2.1
+  version: 6.3.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-29 00:00:00.000000000 Z
+date: 2015-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -137,6 +137,7 @@ files:
 - ".gitignore"
 - ".travis.yml"
 - CHANGELOG
+- CONTRIBUTING.md
 - Gemfile
 - LICENSE
 - README.md
@@ -148,6 +149,7 @@ files:
 - config/routes.rb
 - lib/generators/shopify_app/controllers/controllers_generator.rb
 - lib/generators/shopify_app/install/install_generator.rb
+- lib/generators/shopify_app/install/templates/_flash_messages.html.erb
 - lib/generators/shopify_app/install/templates/embedded_app.html.erb
 - lib/generators/shopify_app/install/templates/home_controller.rb
 - lib/generators/shopify_app/install/templates/index.html.erb
@@ -160,9 +162,9 @@ files:
 - lib/generators/shopify_app/routes/templates/routes.rb
 - lib/generators/shopify_app/shop_model/shop_model_generator.rb
 - lib/generators/shopify_app/shop_model/templates/db/migrate/create_shops.rb
-- lib/generators/shopify_app/shop_model/templates/session_storage.rb
 - lib/generators/shopify_app/shop_model/templates/shop.rb
 - lib/generators/shopify_app/shop_model/templates/shopify_session_repository.rb
+- lib/generators/shopify_app/shop_model/templates/shops.yml
 - lib/generators/shopify_app/shopify_app_generator.rb
 - lib/generators/shopify_app/views/views_generator.rb
 - lib/shopify_app.rb
@@ -171,11 +173,15 @@ files:
 - lib/shopify_app/engine.rb
 - lib/shopify_app/in_memory_session_store.rb
 - lib/shopify_app/login_protection.rb
+- lib/shopify_app/session_storage.rb
 - lib/shopify_app/sessions_controller.rb
 - lib/shopify_app/shop.rb
 - lib/shopify_app/shopify_session_repository.rb
 - lib/shopify_app/utils.rb
 - lib/shopify_app/version.rb
+- lib/shopify_app/webhooks_controller.rb
+- lib/shopify_app/webhooks_manager.rb
+- lib/shopify_app/webhooks_manager_job.rb
 - shipit.rubygems.yml
 - shopify_app.gemspec
 - test/app_templates/app/controllers/application_controller.rb
@@ -207,6 +213,8 @@ files:
 - test/shopify_app/login_protection_test.rb
 - test/shopify_app/shopify_session_repository_test.rb
 - test/shopify_app/utils_test.rb
+- test/shopify_app/webhooks_controller_test.rb
+- test/shopify_app/webhooks_manager_test.rb
 - test/support/generator_test_helpers.rb
 - test/test_helper.rb
 homepage: 

data/lib/generators/shopify_app/shop_model/templates/session_storage.rb

@@ -1,16 +0,0 @@
-class SessionStorage
-  def self.store(session)
-    shop = Shop.find_or_initialize_by(shopify_domain: session.url)
-    shop.shopify_token = session.token
-    shop.save!
-    shop.id
-  end
-
-  def self.retrieve(id)
-    return unless id
-    shop = Shop.find(id)
-    ShopifyAPI::Session.new(shop.shopify_domain, shop.shopify_token)
-  rescue ActiveRecord::RecordNotFound
-    nil
-  end
-end