shopify_app 17.0.5 → 17.1.0

data/docs/shopify_app/generators.md

@@ -0,0 +1,127 @@
+# Generators
+
+> Listed below are the generators currently offered by the Shopify App gem. To learn more about how this gem creates an embedded app, start with the [default Shopify App generator](#-environment-rails-generate-shopify_app).
+
+---
+
+#### `$ [environment] rails generate shopify_app`
+
+The default generator will run the [`install`](#-rails-generate-shopify_appinstall-flags), [`shop_model`](#-rails-generate-shopify_appshop_model), [`authenticated_controller`](#-rails-generate-shopify_appauthenticated_controller), and [`home_controller`](#-rails-generate-shopify_apphome_controller-flags) generators. This is the recommended way to start a new app from scratch.
+
+##### Environment
+
+###### `SHOPIFY_APP_DISABLE_WEBPACKER`
+
+**[Optional]** Specify this environment variable if your app uses sprockets with Rails 6 or to generate a Shopify App without webpacker.
+
+*Example:*
+
+Run:
+
+```terminal
+$ SHOPIFY_APP_DISABLE_WEBPACKER=1 rails generate shopify_app
+```
+
+Add the following code to your ShopifyApp configuration block:
+
+```ruby
+ShopifyApp.configure do |config|
+  config.disable_webpacker = true
+end
+```
+
+---
+
+#### `$ rails generate shopify_app:install [flags]`
+
+This generator adds ShopifyApp and the required initializers to the host Rails application. You can update any of these settings later.
+
+##### Flags
+
+###### `--application_name`
+
+The name of your app. The flag can be supplied with or without double-quotes.
+
+*Example:* `--application_name "My Shopify App"`
+
+###### `--scope`
+
+The [OAuth access scope(s)](https://shopify.dev/docs/admin-api/access-scopes) required by your app. Delimit multiple access scopes using a comma-space. The flag can be supplied with or without double-quotes.
+
+*Example:* `--scope read_products, write_orders`
+
+*Example:* `--scope "read_products, write_orders"`
+
+###### `--embedded`
+
+Specify whether the app is an embedded app. Apps are embedded by default.
+
+*Example:* `--embedded false`
+
+###### `--with-cookie-authentication`
+
+**[Not recommended]** Specify whether the app uses cookies to authenticate. By default, the app is configured to use [session tokens](https://shopify.dev/concepts/apps/building-embedded-apps-using-session-tokens).
+
+*Example:* `--with-cookie-authentication true`
+
+---
+
+#### `$ rails generate shopify_app:shop_model`
+
+This generator creates a `Shop` model and a migration to store shop installation records. See [*Shop-based token strategy*](/docs/shopify_app/session-repository.md#shop-based-token-storage) to learn more.
+
+---
+
+#### `$ rails generate shopify_app:user_model`
+
+This generator creates a `User` model and a migration to store user records. See [*User-based token strategy*](/docs/shopify_app/session-repository.md#user-based-token-storage) to learn more.
+
+---
+
+#### `$ rails generate shopify_app:authenticated_controller`
+
+This generator creates a sample authenticated controller. By default, inheriting from this controller protects your app controllers using session tokens. See [*Authentication*](/docs/shopify_app/authentication.md) to learn more.
+
+---
+
+#### `$ rails generate shopify_app:home_controller [flags]`
+
+This generator creates a sample home controller with a view that displays a shop's products. This generator also runs the [`products_controller`](#-rails-generate-shopify_appproducts_controller) generator.
+
+##### Flags
+
+###### `--with-cookie-authentication`
+
+**[Not recommended]**  This flag generates an authenticated home controller. Use this flag only if your app uses cookies to authenticate. By default, the home controller is unauthenticated.
+
+---
+
+#### `$ rails generate shopify_app:products_controller`
+
+This generator creates a sample products API controller to fetch products using the Shopify REST API.
+
+---
+
+#### `$ rails generate shopify_app:add_after_authenticate_job`
+
+**[Optional]** This generator creates a skeleton job that runs after the OAuth authorization flow. See [*Run jobs after the OAuth flow*](/docs/shopify_app/authentication.md#run-jobs-after-the-oauth-flow) for more information.
+
+---
+
+#### `$ rails generate shopify_app:app_proxy_controller`
+
+**[Optional]** This generator creates the app proxy controller to handle proxy requests to the app from your shop storefront. It also modifies 'config/routes.rb' with a namespace route and creates a sample view that displays current shop information using the LiquidAPI. See [*Verify HTTP requests sent via an app proxy*](/docs/shopify_app/engine.md#verify-http-requests-sent-via-an-app-proxy) for more information.
+
+---
+
+#### `$ rails generate shopify_app:marketing_activity_extension`
+
+**[Optional]** This generator creates a controller with the endpoints required to build a [marketing activities extension](https://shopify.dev/docs/marketing-activities). The extension is generated with the base URL `/marketing_activities`. This URL would need to be configured in the Shopify Partners dashboard.
+
+---
+
+#### `$ rails generate shopify_app:controllers`
+
+**[Optional]** This generator is for your convenience. Run this generator if you would like to override code that is part of the Shopify App Rails engine.
+
+*Example:* The Shopify App Rails engine provides a sample [`SessionsController`](/app/controllers/shopify_app/sessions_controller.rb). Running this generator copies this controller to your app so you can begin extending it. Routes and views follow the same pattern.

data/docs/shopify_app/handling-access-scopes-changes.md

@@ -0,0 +1,8 @@
+# Handling changes in access scopes
+The Shopify App gem provides handling changes to scopes for both shop/offline and user/online tokens. To enable your app to login via OAuth on scope changes, you can set the following configuration flag:
+```ruby
+ShopifyApp.configuration.reauth_on_access_scope_changes = true
+```
+
+## ShopAccessScopesVerification
+The `ShopifyApp::ShopAccessScopesVerification` concern helps merchants grant new access scopes requested by the app. The concern compares the current access scopes granted by the shop and compares them with the scopes requested by the app. If there is a mismatch in configuration, the merchant is redirected to login via OAuth and grant the net new scopes.

data/docs/shopify_app/script-tags.md

@@ -0,0 +1,28 @@
+# ScriptTags
+
+#### Table of contents
+
+[Manage ScriptTags using the Shopify App initializer](#manage-scripttags-using-the-shopify-app-initializer)
+
+## Manage ScriptTags using the Shopify App initializer
+
+As with webhooks, ShopifyApp can manage your app's [ScriptTags](https://shopify-dev-staging.shopifycloud.com/docs/admin-api/graphql/reference/online-store/scripttag) for you by setting which scripttags you require in the initializer:
+
+```ruby
+ShopifyApp.configure do |config|
+  config.scripttags = [
+    {event:'onload', src: 'https://my-shopifyapp.herokuapp.com/fancy.js'},
+    {event:'onload', src: ->(domain) { dynamic_tag_url(domain) } }
+  ]
+end
+```
+
+You also need to have write_script_tags permission in the config scope in order to add script tags automatically:
+
+```ruby
+ config.scope = '... , write_script_tags'
+```
+
+Scripttags are created in the same way as the [Webhooks](/docs/shopify_app/webhooks.md), with a background job which will create the required scripttags.
+
+If `src` responds to `call` its return value will be used as the scripttag's source. It will be called on scripttag creation and deletion.

data/docs/shopify_app/session-repository.md

@@ -0,0 +1,88 @@
+# Session repository
+
+#### Table of contents
+
+[`ShopifyApp::SessionRepository`](#shopifyappsessionrepository)
+  * [Shop-based token storage](#shop-based-token-storage)
+  * [User-based token storage](#user-based-token-storage)
+
+[Access scopes](#access-scopes)
+  * [`ShopifyApp::ShopSessionStorageWithScopes`](#shopifyappshopsessionstoragewithscopes)
+  * [``ShopifyApp::UserSessionStorageWithScopes``](#shopifyappusersessionstoragewithscopes)
+
+[Migrating from shop-based to user-based token strategy](#migrating-from-shop-based-to-user-based-token-strategy)
+
+## ShopifyApp::SessionRepository
+
+`ShopifyApp::SessionRepository` allows you as a developer to define how your sessions are stored and retrieved for shops. The `SessionRepository` is configured in the `config/initializers/shopify_app.rb` file and can be set to any object that implements `self.store(auth_session, *args)` which stores the session and returns a unique identifier and `self.retrieve(id)` which returns a `ShopifyAPI::Session` for the passed id. These methods are already implemented as part of the `ShopifyApp::SessionStorage` concern but can be overridden for custom implementation.
+
+### Shop-based token storage
+
+Storing tokens on the store model means that any user login associated with the store will have equal access levels to whatever the original user granted the app.
+```sh
+$ rails generate shopify_app:shop_model
+```
+This will generate a shop model which will be the storage for the tokens necessary for authentication.
+
+### User-based token storage
+
+A more granular control over the level of access per user on an app might be necessary, to which the shop-based token strategy is not sufficient. Shopify supports a user-based token storage strategy where a unique token to each user can be managed. Shop tokens must still be maintained if you are running background jobs so that you can make use of them when necessary.
+```sh
+$ rails generate shopify_app:shop_model
+$ rails generate shopify_app:user_model
+```
+This will generate a shop model and user model, which will be the storage for the tokens necessary for authentication.
+
+The current Shopify user will be stored in the rails session at `session[:shopify_user]`
+
+Read more about Online vs. Offline access [here](https://help.shopify.com/api/getting-started/authentication/oauth).
+
+## Access scopes
+
+If you want to customize how access scopes are stored for shops and users, you can implement the `access_scopes` getters and setters in the models that include `ShopifyApp::ShopSessionStorageWithScopes` and `ShopifyApp::UserSessionStorageWithScopes` as shown:
+
+### `ShopifyApp::ShopSessionStorageWithScopes`
+```ruby
+class Shop < ActiveRecord::Base
+  include ShopifyApp::ShopSessionStorageWithScopes
+
+  def access_scopes=(scopes)
+    # Store access scopes
+  end
+  def access_scopes
+    # Find access scopes
+  end
+end
+```
+
+### `ShopifyApp::UserSessionStorageWithScopes`
+```ruby
+class User < ActiveRecord::Base
+  include ShopifyApp::UserSessionStorageWithScopes
+
+  def access_scopes=(scopes)
+    # Store access scopes
+  end
+  def access_scopes
+    # Find access scopes
+  end
+end
+```
+## Migrating from shop-based to user-based token strategy
+
+1. Run the `user_model` generator as mentioned above.
+2. Ensure that both your `Shop` model and `User` model includes the necessary concerns `ShopifyApp::ShopSessionStorage` and `ShopifyApp::UserSessionStorage`.
+3. Make changes to 2 initializer files as shown below:
+```ruby
+# In the `omniauth.rb` initializer:
+provider :shopify,
+  ...
+  setup: lambda { |env|
+    configuration = ShopifyApp::OmniauthConfiguration.new(env['omniauth.strategy'], Rack::Request.new(env))
+    configuration.build_options
+  }
+
+# In the `shopify_app.rb` initializer:
+config.shop_session_repository = {YOUR_SHOP_MODEL_CLASS}
+config.user_session_repository = {YOUR_USER_MODEL_CLASS}
+```

data/docs/shopify_app/testing.md

@@ -0,0 +1,38 @@
+# Testing
+
+#### Table of contents
+
+[Using test helpers inside your application](#using-test-helpers-inside-your-application)
+
+[Testing an embedded app outside the Shopify admin](#testing-an-embedded-app-outside-the-shopify-admin)
+
+## Using test helpers inside your application
+
+A test helper that will allow you to test `ShopifyApp::WebhookVerification` in the controller from your app, to use this test, you need to `require` it directly inside your app `test/controllers/webhook_verification_test.rb`.
+
+```ruby
+    require 'test_helper'
+    require 'action_controller'
+    require 'action_controller/base'
+    require 'shopify_app/test_helpers/webhook_verification_helper'
+```
+
+Or you can require in your `test/test_helper.rb`.
+
+```ruby
+  ENV['RAILS_ENV'] ||= 'test'
+  require_relative '../config/environment'
+  require 'rails/test_help'
+  require 'byebug'
+  require 'shopify_app/test_helpers/all'
+```
+
+With `lib/shopify_app/test_helpers/all'` more tests can be added and will only need to be required in once in your library.
+
+## Testing an embedded app outside the Shopify admin
+
+By default, loading your embedded app will redirect to the Shopify admin, with the app view loaded in an `iframe`. If you need to load your app outside of the Shopify admin (e.g., for performance testing), you can change `forceRedirect: true` to `false` in `ShopifyApp.init` block in the `embedded_app` view. To keep the redirect on in production but off in your `development` and `test` environments, you can use:
+
+```javascript
+forceRedirect: <%= Rails.env.development? || Rails.env.test? ? 'false' : 'true' %>
+```

data/docs/shopify_app/webhooks.md

@@ -0,0 +1,72 @@
+# Webhooks
+
+#### Table of contents
+
+[Manage webhooks using `ShopifyApp::WebhooksManager`](#manage-webhooks-using-shopifyappwebhooksmanager)
+
+## Manage webhooks using `ShopifyApp::WebhooksManager`
+
+See [`ShopifyApp::WebhooksManager`](/lib/shopify_app/managers/webhooks_manager.rb)
+ShopifyApp can manage your app's webhooks for you if you set which webhooks you require in the initializer:
+
+```ruby
+ShopifyApp.configure do |config|
+  config.webhooks = [
+    {topic: 'carts/update', address: 'https://example-app.com/webhooks/carts_update'}
+  ]
+end
+```
+
+When the [OAuth callback](/docs/shopify_app/authentication.md#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.
+
+ShopifyApp also provides a [WebhooksController](/app/controllers/shopify_app/webhooks_controller.rb) that receives webhooks and queues a job based on the received topic. For example, if you register the webhook from above, then all you need to do is create a job called `CartsUpdateJob`. The job will be queued with 2 params: `shop_domain` and `webhook` (which is the webhook body).
+
+If you would like to namespace your jobs, you may set `webhook_jobs_namespace` in the config. For example, if your app handles webhooks from other ecommerce applications as well, and you want Shopify cart update webhooks to be processed by a job living in `jobs/shopify/webhooks/carts_update_job.rb` rather than `jobs/carts_update_job.rb`):
+
+```ruby
+ShopifyApp.configure do |config|
+  config.webhook_jobs_namespace = 'shopify/webhooks'
+end
+```
+
+If you are only interested in particular fields, you can optionally filter the data sent by Shopify by specifying the `fields` parameter in `config/webhooks`. Note that you will still receive a webhook request from Shopify every time the resource is updated, but only the specified fields will be sent.
+
+```ruby
+ShopifyApp.configure do |config|
+  config.webhooks = [
+    {topic: 'products/update', address: 'https://example-app.com/webhooks/products_update', fields: ['title', 'vendor']}
+  ]
+end
+```
+
+If you'd rather implement your own controller then you'll want to use the [`ShopifyApp::WebhookVerification`](/lib/shopify_app/controller_concerns/webhook_verification.rb) module to verify your webhooks, example:
+
+```ruby
+class CustomWebhooksController < ApplicationController
+  include ShopifyApp::WebhookVerification
+
+  def carts_update
+    params.permit!
+    SomeJob.perform_later(shop_domain: shop_domain, webhook: webhook_params.to_h)
+    head :no_content
+  end
+
+  private
+
+  def webhook_params
+    params.except(:controller, :action, :type)
+  end
+end
+```
+
+The module skips the `verify_authenticity_token` before_action and adds an action to verify that the webhook came from Shopify. You can now add a post route to your application, pointing to the controller and action to accept the webhook data from Shopify.
+
+The WebhooksManager uses ActiveJob. If ActiveJob is not configured then by default Rails will run the jobs inline. However, it is highly recommended to configure a proper background processing queue like Sidekiq or Resque in production.
+
+ShopifyApp can create webhooks for you using the `add_webhook` generator. This will add the new webhook to your config and create the required job class for you.
+
+```
+rails g shopify_app:add_webhook -t carts/update -a https://example.com/webhooks/carts_update
+```
+
+Where `-t` is the topic and `-a` is the address the webhook should be sent to.

data/lib/generators/shopify_app/home_controller/templates/home_controller.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 class HomeController < AuthenticatedController
+  include ShopifyApp::ShopAccessScopesVerification
+
   def index
     @products = ShopifyAPI::Product.find(:all, params: { limit: 10 })
     @webhooks = ShopifyAPI::Webhook.find(:all)

data/lib/generators/shopify_app/home_controller/templates/unauthenticated_home_controller.rb

@@ -3,6 +3,7 @@
 class HomeController < ApplicationController
   include ShopifyApp::EmbeddedApp
   include ShopifyApp::RequireKnownShop
+  include ShopifyApp::ShopAccessScopesVerification
 
   def index
     @shop_origin = current_shopify_domain

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

@@ -30,9 +30,11 @@ module ShopifyApp
           copy_file('omniauth.rb', 'config/initializers/omniauth.rb')
         end
 
+        return if !Rails.env.test? && shopify_provider_exists?
+
         inject_into_file(
           'config/initializers/omniauth.rb',
-          File.read(File.expand_path(find_in_source_paths('shopify_provider.rb'))),
+          shopify_provider_template,
           after: "Rails.application.config.middleware.use(OmniAuth::Builder) do\n"
         )
       end
@@ -72,6 +74,33 @@ module ShopifyApp
 
       private
 
+      def shopify_provider_exists?
+        File.open("config/initializers/omniauth.rb") do |file|
+          file.each_line do |line|
+            if line =~ /provider :shopify/
+              puts "\e[33m#{omniauth_warning}\e[0m"
+              return true
+            end
+          end
+        end
+        false
+      end
+
+      def omniauth_warning
+        <<~OMNIAUTH
+          \n[WARNING] The Shopify App generator attempted to add the following Shopify Omniauth \
+          provider 'config/initializers/omniauth.rb':
+
+          \e[0m#{shopify_provider_template}\e[33m
+
+          Consider updating 'config/initializers/omniauth.rb' to match the configuration above.
+        OMNIAUTH
+      end
+
+      def shopify_provider_template
+        File.read(File.expand_path(find_in_source_paths('shopify_provider.rb.tt')))
+      end
+
       def embedded_app?
         options['embedded'] == 'true'
       end

data/lib/generators/shopify_app/install/templates/omniauth.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
+
 Rails.application.config.middleware.use(OmniAuth::Builder) do
 end

data/lib/generators/shopify_app/install/templates/shopify_app.rb.tt

@@ -7,14 +7,17 @@ ShopifyApp.configure do |config|
   config.after_authenticate_job = false
   config.api_version = "<%= @api_version %>"
   config.shop_session_repository = 'Shop'
+
+  config.reauth_on_access_scope_changes = true
+
   config.allow_jwt_authentication = <%= !with_cookie_authentication? %>
   config.allow_cookie_authentication = <%= with_cookie_authentication? %>
 
   config.api_key = ENV.fetch('SHOPIFY_API_KEY', '').presence
   config.secret = ENV.fetch('SHOPIFY_API_SECRET', '').presence
   if defined? Rails::Server
-    raise('Missing SHOPIFY_API_KEY. See https://github.com/Shopify/shopify_app#api-keys') unless config.api_key
-    raise('Missing SHOPIFY_API_SECRET. See https://github.com/Shopify/shopify_app#api-keys') unless config.secret
+    raise('Missing SHOPIFY_API_KEY. See https://github.com/Shopify/shopify_app#requirements') unless config.api_key
+    raise('Missing SHOPIFY_API_SECRET. See https://github.com/Shopify/shopify_app#requirements') unless config.secret
   end
 end