Skip to content
CAI
Software that uses CAICheck a score

Shopify/shopify_app

53.8

Adequate · 6 November 2026

3.5k

lines of production code

Ruby

primary language

4

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add background jobs for script tag and webhook management

Introduces two new ActiveJob classes, ScriptTagsManagerJob and WebhooksManagerJob, to handle the creation of script tags and webhooks asynchronously. These jobs allow the application to configure specific background queues via ShopifyApp configuration and manage Shopify API sessions securely during execution.

app/jobs · high confidence

Add client-side redirect helper for App Bridge integration

A new JavaScript module (redirect.js) has been added to handle client-side redirects by reading a target URL from a DOM element's data attribute and opening it in the top-level window. This script is designed to work within the App Bridge ecosystem, ensuring redirects fire reliably even in Turbolinks contexts where standard DOMContentLoaded events may not consistently trigger.

app/assets · high confidence

Add controllers generator for Shopify App engine

Introduces a new Rails generator that copies Shopify App controller files from the engine's source root into the host application's app/controllers/shopify\_app directory, enabling users to easily scaffold or override default controllers.

_lib/generators/shopify\app/controllers · high confidence

Add generator for AfterAuthenticateJob configuration

A new Rails generator (\AddAfterAuthenticateJobGenerator\) has been added to the Shopify App library. When invoked, it automatically configures the \after\_authenticate\_job\ setting in \config/initializers/shopify\_app.rb\ to use \Shopify::AfterAuthenticateJob\ (running inline=false) and generates the corresponding job class file in \app/jobs/\. This simplifies the setup of post-authentication job processing for developers using the gem.

_lib/generators/shopify\_app/add\_after\_authenticate\job · high confidence

The Shopify App gem now includes a generator that scaffolds three ActiveJob classes—CustomersDataRequestJob, CustomersRedactJob, and ShopRedactJob—into your application. These jobs are designed to handle GDPR privacy webhooks by extending ShopifyAPI::Webhooks::WebhookHandler, allowing your app to automatically process customer data requests and redaction events from Shopify.

_lib/generators/shopify\_app/add\_privacy\jobs · high confidence

Add generator for Shopify products controller

A new Rails generator has been added that scaffolds a ProductsController inheriting from AuthenticatedController. Running this generator creates a controller with an index action that fetches the first 10 products via the ShopifyAPI and returns them as JSON, and it also adds a route mapping GET /products to this controller action.

_lib/generators/shopify\_app/products\controller · high confidence

Add token rotation generator and job

The library now provides a generator (\rotate\_shopify\_token\_job\) that installs a background job and a rake task to rotate Shopify access tokens. The generated job (\RotateShopifyTokenJob\) performs an OAuth token refresh for a specific shop by posting to the Shopify admin API and updating the stored token, while the rake task (\shopify:rotate\_shopify\_tokens\) iterates over active shops to trigger this rotation.

_lib/generators/shopify\_app/rotate\_shopify\_token\job · high confidence

Added generator for App Proxy controller and views

A new Rails generator has been added to scaffold the necessary components for Shopify App Proxy integration. Running this generator creates an AppProxyController that includes verification logic, an index view template displaying shop details via Liquid, and the corresponding route configuration in config/routes.rb, simplifying the setup process for developers.

_lib/generators/shopify\_app/app\_proxy\controller · high confidence

Added template for AfterAuthenticateJob

The generator now includes a template for an \AfterAuthenticateJob\ class that inherits from \ActiveJob::Base\. When generated, this job accepts a \shop\_domain\, looks up the corresponding \Shop\ record, and executes its block within a \with\_shopify\_session\ context, providing a structured way to run post-authentication logic.

_lib/generators/shopify\_app/add\_after\_authenticate\job/templates · high confidence

Added user model and fixture templates for per-user token storage

The generator now includes a new User model template that includes ShopifyApp::UserSessionStorage and defines an api\_version method, alongside a users.yml fixture file containing sample shopify\_domain, shopify\_token, and shopify\_user\_id fields. This enables applications to generate a user-specific authentication model required for per-user token support.

_lib/generators/shopify\_app/user\model/templates · high confidence

Added views generator to scaffold Shopify app templates

A new \ViewsGenerator\ class has been introduced to the Shopify App library. This generator automatically copies view templates from the library's source root into the host application's \app/views\ directory, allowing users to easily scaffold or update the default Shopify app interface views.

_lib/generators/shopify\app/views · high confidence

Adds default route templates for authentication and webhooks

The generator now includes a new default routes template that defines standard paths for the authentication flow (login, callback, logout) and a namespace for receiving webhooks. This provides users with a pre-configured routing structure for session management and webhook handling out of the box.

_lib/generators/shopify\app/routes/templates · high confidence

Initial release of the Shopify App gem

This entry marks the initial release of the Shopify App gem, providing a Rails engine, generators, and modules to help developers build applications that embed in the Shopify Admin. The release includes OAuth implementation, session token authentication, and support for webhooks and billing. It establishes the project structure with configuration files for Ruby 3.2.2, Node 20.10.0, and development tooling like RuboCop and Babel.

(repo-wide) · high confidence

New embedded app generator templates with App Bridge 2 and flash handling

The install generator now includes a new set of templates for embedded apps, providing a complete layout (\embedded\_app.html.erb\) that integrates App Bridge 2 for UI components like the TitleBar and handles flash messages via a dedicated partial and JavaScript handler. The configuration template (\shopify\_app.rb.tt\) is updated to enable the new embedded auth strategy by default, configure session storage, and register standard webhooks (uninstalled, GDPR). Additionally, separate JavaScript entry points are provided for Webpacker and Importmap setups to ensure compatibility with modern Rails asset pipelines.

_lib/generators/shopify\app/install/templates · high confidence

New generator for AuthenticatedController concern

A new generator has been added that creates an \AuthenticatedController\ base class in \app/controllers\. This generated controller includes the \ShopifyApp::EnsureHasSession\ concern, providing a standardized base for controllers that require an active Shopify session.

_lib/generators/shopify\_app/authenticated\controller · high confidence

New generator for adding webhook jobs and configuration

The Shopify App gem now includes an \add\_webhook\ generator that simplifies setting up new webhooks. Running this generator automatically updates the \config/initializers/shopify\_app.rb\ file to register the webhook topic and path, and creates a corresponding job class in \app/jobs/\ to handle the webhook payload. The generator accepts \--topic\ and \--path\ arguments to define the specific webhook details and respects the configured \webhook\_jobs\_namespace\ for job placement.

_lib/generators/shopify\_app/add\webhook · high confidence

New generator for declarative Shopify webhooks

A new Rails generator (\add\_declarative\_webhook\) is now available to scaffold webhook handling. When invoked with \--topic\ and \--path\ options, it creates a dedicated job class (placed in \app/jobs/\), a controller with Shopify signature verification (placed in \app/controllers/webhooks/\), and the corresponding route in \config/routes.rb\. The generated job looks up the shop by domain and executes the webhook payload within a Shopify session context.

_lib/generators/shopify\_app/add\_declarative\webhook · high confidence

New generator templates for authenticated and unauthenticated home controllers

The generator now provides new template files for the home controller, including an authenticated version that includes the \ShopifyApp::ShopAccessScopesVerification\ concern and an unauthenticated version that handles redirection to the embedded app URL. The generated home page template has been updated to display products and webhooks, using App Bridge session tokens for embedded apps and falling back to direct links for non-embedded contexts. This change introduces the structure for the home controller generator, separating authenticated and unauthenticated flows and adding support for displaying webhooks alongside products.

_lib/generators/shopify\_app/home\controller/templates · high confidence

New managers for script tags and webhooks

Added \ScriptTagsManager\ and \WebhooksManager\ classes to \lib/shopify\_app/managers\ to centralize the lifecycle management of script tags and webhooks. The \ScriptTagsManager\ handles queueing, creating, destroying, and recreating script tags, including logic to check for app block support in themes before creation. The \WebhooksManager\ manages webhook registration, destruction, and recreation, deducing the webhook path from the address and handling job class resolution for HTTP delivery methods.

_lib/shopify\app/managers · high confidence

New test helpers for Shopify sessions and webhook verification

Added \ShopifySessionHelper\ and \WebhookVerificationHelper\ modules to simplify testing. \ShopifySessionHelper\ provides a \setup\_shopify\_session\ method to stub session loading and activation, while \WebhookVerificationHelper\ offers \authorized\_webhook\_verification\_headers!\ (accepting a params hash) and \unauthorized\_webhook\_verification\_headers!\ to simulate valid and invalid webhook HMAC signatures in tests.

_lib/shopify\_app/test\helpers · high confidence

Removals

Removal of legacy Rails 2 generator and templates

The \shopify\_app\ generator for Rails 2 has been removed. This change deletes the generator script, its route-insertion helpers, and all associated templates (including the \shopify.yml\ configuration file, controllers, helpers, and stylesheets). Users relying on this generator to scaffold a basic Shopify application in a Rails 2 environment will no longer have this automated setup available.

generators · high confidence

Removal of legacy Shopify app login template

The legacy login view template for the Shopify app generator has been removed. This deletes the previous implementation that prompted users to register an app by entering a shop URL and submitting an authentication form, effectively removing this specific user-facing installation screen from the generated application.

_generators/shopify\app/templates/app/views/login · high confidence

Removed legacy HomeController and LoginController templates

The generator no longer includes the legacy HomeController and LoginController templates. This removes the default scaffolding for displaying products/orders and the previous manual login flow, indicating a shift in the generated application structure or authentication mechanism.

_generators/shopify\app/templates/app/controllers · high confidence

Removed legacy application layout template

The generator no longer includes the legacy \application.html.erb\ layout file, which previously relied on deprecated Prototype JavaScript libraries and hardcoded Shopify demo navigation elements. Users generating new applications will no longer receive this outdated layout structure.

_generators/shopify\app/templates/app/views/layouts · high confidence

Removed legacy home view templates

The generator no longer includes the \design\, \index\, and \welcome\ view templates in the \app/views/home\ directory. These files, which previously provided a styled overview of CSS classes, a dashboard-style listing of orders and products, and a multi-step authentication guide, have been deleted from the generated application structure.

_generators/shopify\app/templates/app/views/home · high confidence

Behavioural changes

Added Rails application preparation script to prevent Spin infrastructure misidentification

A new executable script, .spin/rails/prepare-application, has been added to the project. This script runs 'bundle install' and serves to prevent the Spin infrastructure from incorrectly inferring the project as a standard Rails application, thereby avoiding snapshot failures associated with that misidentification.

.spin · high confidence

App uninstalled job now raises an error when the shop is not found

The generated job for handling app uninstalled webhooks has been updated to explicitly raise an ActiveRecord::RecordNotFound error if the shop associated with the uninstalled event cannot be located in the database. Previously, the job would simply log an error and continue, but it now fails fast to ensure that missing shop records are not silently ignored during the uninstallation process.

_lib/generators/shopify\_app/add\_app\_uninstalled\job · high confidence

Automatic token refresh on 401 Unauthorized errors

The Shopify Admin API client now automatically handles 401 Unauthorized errors by exchanging the current ID token for a new access token and retrying the request, rather than failing immediately. This change, implemented in the new \WithTokenRefetch\ module, ensures that transient authentication issues do not disrupt API calls, improving reliability for users interacting with the Shopify Admin API.

_lib/shopify\_app/admin\api · high confidence

Explicitly defined engine routes for authentication, callbacks, and webhooks

The application now explicitly defines its internal routing table within the ShopifyApp engine, replacing implicit or mounted route behavior. This change introduces dedicated routes for the login flow (including a new \patch\_shopify\_id\_token\ endpoint for session token updates), the OAuth callback, and webhook reception. To ensure backward compatibility, legacy route paths are preserved as fallbacks when custom configuration paths differ from the defaults, preventing breaking changes for existing integrations while standardizing the route structure.

config · high confidence

Extracted token exchange logic into a dedicated class with improved error handling

The token exchange process has been refactored from a concern into a dedicated \ShopifyApp::Auth::TokenExchange\ class. This change centralizes the logic for exchanging session tokens for both offline and online access tokens, ensuring that the correct token type is requested based on configuration. The new implementation includes robust error handling for invalid JWT tokens, HTTP response errors, and concurrent access issues (such as \ActiveRecord::RecordNotUnique\ or \RecordInvalid\), preventing crashes during race conditions while still logging relevant debug information. Users benefit from more reliable session management and clearer error reporting during the authentication flow.

_shopify\app · high confidence

Inline CSS styles added for Polaris UI components

The Shopify app installation and layout views now include embedded CSS styles for core Polaris components, including buttons, cards, forms, empty states, typography, and page layout. This change ensures consistent visual presentation of the app installation page and related interfaces by defining styles for elements like .Polaris-Button, .Polaris-Card, .Polaris-TextField, and .Polaris-EmptyState directly within the view partials.

_app/views/shopify\app/partials · high confidence

Introduce access scope strategies for granular scope management

The library now uses dedicated strategy classes to determine when and how access scopes are updated. A new \NoopStrategy\ disables automatic scope updates, while \ShopStrategy\ and \UserStrategy\ handle scope verification and updates for shop-level and user-level sessions respectively, allowing the app to react to configuration changes based on the specific session context.

_lib/shopify\_app/access\scopes · high confidence

Major library restructuring and removal of legacy components

The library has been completely rewritten to modernize its architecture. The legacy \lib/shopify\_api.rb\ module, which previously provided its own session management and ActiveResource-based models, has been removed in favor of the external \shopify\_api\ gem. Similarly, the \ShopifyLoginProtection\ concern has been deleted, with authentication logic now handled by a comprehensive set of new controller concerns (such as \login\_protection\, \token\_exchange\, and \payload\_verification\) and a new \PostAuthenticateTasks\ class that manages webhook and script tag installation. The gem now relies on \redirect\_safely\ and \addressable\ for core utilities and introduces dedicated managers for webhooks and script tags.

lib · high confidence

Migrate full-page redirect to use App Bridge

The shared redirect view now loads the App Bridge library from the Shopify CDN and utilizes it to handle redirections, replacing the previous implementation. This change ensures that redirects are processed correctly within the Shopify admin iframe context, improving reliability and responsiveness for users navigating between apps and the host shop.

_app/views/shopify\app/shared · high confidence

New App Bridge layout template for session token patching

A new layout template (app\_bridge.html.erb) has been added to the Shopify App views, providing the base HTML structure for App Bridge integration. This layout includes the App Bridge JavaScript library from Shopify's CDN, injects the application's API key, and yields content to support the new route for patching session tokens from App Bridge Next.

_app/views/shopify\app/layouts · high confidence

New embedded authentication strategy and session validation concerns

The app introduces a new embedded authentication flow controlled by the \use\_new\_embedded\_auth\_strategy?\ configuration. When enabled, controllers use the new \EnsureHasSession\ and \EnsureInstalled\ concerns which rely on \TokenExchange\ and \activate\_shopify\_session\ instead of the legacy \LoginProtection\ and \validate\_non\_embedded\_session\. A new \EnsureAuthenticatedLinks\ concern handles JWT validation for deep links, redirecting to a splash page with embedded parameters if the JWT is missing. Additionally, \ShopAccessScopesVerification\ now skips scope checks for the new strategy, as scope updates are handled automatically via token exchange.

app/controllers/concerns · high confidence

New session storage architecture with automatic token refresh and deprecation of legacy scopes modules

The session management layer has been restructured to use a new \SessionRepository\ that delegates to separate \ShopSessionStorage\ and \UserSessionStorage\ modules, replacing the previous unified approach. The new \ShopSessionStorage\ now automatically handles access scopes, expiry dates, and refresh tokens, and includes logic to automatically refresh expired offline access tokens using a stored refresh token. The legacy \ShopSessionStorageWithScopes\ and \UserSessionStorageWithScopes\ modules are now deprecated and will be removed in version 24.0.0. Additionally, an \InMemorySessionStore\ is provided for development and testing, which raises an error if used in production.

_lib/shopify\app/session · high confidence

Optional unauthenticated home controller generator

The home controller generator now supports creating an unauthenticated home controller when the app is configured as embedded. Previously, the generator always produced a controller requiring authentication; it now conditionally selects between the standard authenticated template and a new 'unauthenticated\_home\_controller.rb' template based on whether the app is embedded and if the user explicitly opts out of authentication requirements.

_lib/generators/shopify\_app/home\controller · high confidence

Redesigned app installation page with Polaris styling and dynamic branding

The app installation view has been updated to use Shopify Polaris design components, providing a consistent and modern user interface for the login and installation flow. The page now dynamically displays the application name from the configuration, falling back to a default title if not set, and includes improved error handling to show inline validation messages when an invalid shop domain is entered.

_app/views/shopify\app/sessions · high confidence

Refactored authentication and security into modular controller concerns

The authentication and security logic in the gem has been reorganized into a set of dedicated controller concerns to improve clarity and maintainability. Key changes include the introduction of \TokenExchange\ to handle JWT-based session activation and token patching, \LoginProtection\ to manage session validation and login redirects, and \EmbeddedApp\ to handle embedded-specific headers and redirections. Security is now enforced through separate concerns: \CsrfProtection\ skips forgery protection when a valid session token is present, \AppProxyVerification\ validates HMAC signatures for proxy requests, and \WebhookVerification\ validates webhook payloads. Additional concerns like \EnsureBilling\ manage subscription checks, \PayloadVerification\ provides reusable HMAC logic, and \FrameAncestors\ configures Content Security Policy headers for embedded contexts. This structure allows developers to compose specific security and authentication behaviors for their controllers.

_lib/shopify\_app/controller\concerns · high confidence

Refactored authentication and webhook controllers to use ShopifyAPI

The Shopify app gem's core controllers have been rewritten to integrate with the new ShopifyAPI library, shifting session persistence and OAuth logic from the gem to the application. The SessionsController now supports a new embedded authentication strategy that redirects users to the Shopify managed install path, while the CallbackController handles the OAuth completion by validating auth callbacks, saving sessions, and managing user token flows. Additionally, the WebhooksController now utilizes the ShopifyAPI::Webhooks::Registry for processing incoming webhooks, and a new ExtensionVerificationController has been added to handle HMAC verification for app extensions.

_app/controllers/shopify\app · high confidence

Shop model generator now includes API version method and session storage

The generated Shop model now includes the ShopifyApp::ShopSessionStorage concern and defines an api\_version method that delegates to ShopifyApp.configuration.api\_version, ensuring shops automatically use the configured API version. Additionally, a new shops.yml fixture is generated to provide sample shop data for development and testing.

_lib/generators/shopify\_app/shop\model/templates · high confidence

Shop model generator now supports access scopes and token refresh migrations

The shop model generator has been updated to optionally create additional database migrations for storing OAuth access scopes and token refresh data. When generating the Shop model, users are now prompted to include an \access\_scopes\ column migration and a migration for token expiration fields (\expires\_at\, \refresh\_token\, \refresh\_token\_expires\_at\). These additions can be bypassed during automated CLI usage via the \--new-shopify-cli-app\ flag. The generator also updates the main initializer to replace the in-memory session store with the new Shop model and creates corresponding test fixtures.

_lib/generators/shopify\_app/shop\model · high confidence

Shopify App gem v23.0.3: Configuration, Engine, and Utilities Refactor

This release introduces a centralized \ShopifyApp::Configuration\ class to manage app settings (such as \myshopify\_domain\, \unified\_admin\_domain\, and authentication strategies) and a new \ShopifyApp::Engine\ that isolates the namespace and handles asset precompilation and job parameter redaction. It also adds a \ShopifyApp::Utils\ module for domain sanitization and URL generation, alongside dedicated error classes and a logger that inherits from the Shopify API gem, all bundled in version 23.0.3.

_lib/shopify\app · high confidence

Shopify App routes are now explicitly mounted via generator instead of auto-mounted

The Shopify App engine no longer automatically mounts its routes at the root path. Instead, the new \RoutesGenerator\ explicitly injects session routes into the application's \config/routes.rb\ and removes the previous \mount ShopifyApp::Engine, at: '/'\ line. This change gives developers explicit control over how and where Shopify App routes are mounted in their Rails application, rather than relying on implicit engine mounting.

_lib/generators/shopify\app/routes · high confidence

Unified generator for Shopify app scaffolding

The \shopify\_app\ generator now provides a single entry point that automatically orchestrates the creation of essential app components. Running this generator triggers the addition of uninstalled and privacy webhooks, the installation of the core gem configuration, the creation of the shop model, the setup of the authenticated controller concern, and the generation of a home controller, streamlining the initial setup process for new applications.

_lib/generators/shopify\app · high confidence

Updated Shop model database migration templates

The database migration templates for the Shop model have been updated to include new columns for managing access scopes and token expiry. Specifically, the \create\_shops\ migration now establishes the base table, while new migrations add an \access\_scopes\ column (defaulting to an empty string), as well as \expires\_at\, \refresh\_token\, and \refresh\_token\_expires\_at\ columns to support access token lifecycle management.

_lib/generators/shopify\_app/shop\model/templates/db · high confidence

Updated install generator with new defaults and tunnel support

The Shopify App install generator has been updated to scaffold applications with a default API version of 2025-10 and automatically configure development hosts for ngrok and Cloudflare tunnels. It now generates a dedicated session store initializer and, for embedded apps, provides layout and JavaScript assets tailored to the app's asset pipeline (Webpacker, Importmap, or Sprockets).

_lib/generators/shopify\app/install · high confidence

Updated user model database schema with access scopes and expiration support

The database migration templates for the user model have been updated to support per-user token management. A new migration adds an \access\_scopes\ column (string, defaulting to empty string) to the users table, and another adds an \expires\_at\ column (datetime) to track token validity. The primary \create\_users\ migration now includes a \shopify\_token\ column, establishing the foundation for storing individual user credentials rather than a single shared token.

_lib/generators/shopify\_app/user\model/templates/db · high confidence

User model generator now supports access scopes and session expiry storage

The Shopify App user model generator has been updated to optionally add \access\_scopes\ and \expires\_at\ columns to the User model via new migrations. When generating a new app, users are prompted to include these columns, which allow the app to store OAuth access scopes and check session expiry dates without immediate API calls. The generator also automatically updates the Shopify App initializer to use the User model for session storage instead of the in-memory store.

_lib/generators/shopify\_app/user\model · high confidence

Webhook job generator now raises an error when the shop is not found

The template for generated webhook jobs has been updated to explicitly check for the existence of the shop record during processing. If the shop cannot be found by its domain, the job now logs an error and raises an ActiveRecord::RecordNotFound exception, rather than proceeding with a nil shop object. This change ensures that webhook processing fails fast and visibly when the associated shop is missing, improving error handling and debugging for webhook jobs.

_lib/generators/shopify\_app/add\webhook/templates · high confidence

Test coverage

Add test configuration initializer for ShopifyApp; Added FakeSessionStorage test helper; Added Rails test dummy application configuration; Added controller tests for callback, session, and extension verification flows; Added development environment test template; Added generator tests for ShopifyApp scaffolding; Added integration tests for the webhooks controller; Added route tests for the ShopifyApp engine; Added test coverage for ScriptTagsManager and WebhooksManager; Added test coverage for controller concerns; Added test coverage for controller concerns; Added test dummy application for engine testing; Added test environment configuration for the engine dummy app; Added test fixtures for Rails application configuration and routing; Added test infrastructure and helpers for the engine; Added test support helpers for access scopes and session store strategies; Added tests for Admin API token refetch behavior; Added tests for RailsGeneratorRuntime utility; Added tests for Shopify session test helper; Added tests for access scope update strategies; Added tests for configuration, CSP helpers, and domain utilities; Added tests for post-authenticate tasks and token exchange logic; Added tests for redirect functionality and storage access fixture; Added tests for session storage and repository components; Updated test app templates for Shopify App configuration.

Dependencies

Shopify App gem v23.0.3 requires Rails 7.1+ and Ruby 3.2+

The Shopify App gem has been updated to version 23.0.3, which raises the minimum supported versions to Ruby 3.2 and Rails 7.1 (up to version 9). This release also updates the underlying shopify\_api dependency to version 16.0 and includes updated lock files for both Ruby (Gemfile.lock) and JavaScript (yarn.lock) to reflect these new constraints and their transitive dependencies.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

This is the PUBLIC form of this artifact. Findings are listed in full, but the details of SECURITY findings — which rule fired, in which file, on which line, and how to fix it — are deliberately withheld, and any secret-scanner results are excluded entirely. Where detail is absent here it was REMOVED FOR PUBLICATION; it is not missing from the analysis. The complete artifact is available from the repository owner.

Score

  • CAI 47 → 54 (+6.8)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

Lenses

  • Code Health 57 → 57 (+0.0)
  • Architecture 95 → 95 (+0.1)
  • Maturity 38 → 60 (+21.6)
  • Readiness 47 → 47 (+0.0)
  • Security 66 → 67 (+1.2)
  • Accessibility 57 → 57 (+0.0)

Resolved (12)

  • Boundary-crossing change coupling: sessions_controller.rb ↔ routes.rb (app/controllers/shopify_app/sessions_controller.rb)
  • Duplicate intent for token exchange/session activation. Both types handle the core logic of exchanging a token for a session, but are split across different namespaces with different signatures (one takes an ID token explicitly, the other takes a block). This creates confusion about which entry point to use for standard authentication flows.
  • High CVE: [GHSA redacted] (yarn.lock)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • High: security finding (details withheld)
  • Inconsistent naming for domain-based retrieval. The InMemoryShopSessionStore uses retrieve_by_shopify_domain, while the main SessionRepository uses retrieve_shop_session_by_shopify_domain. The extra 'session' word in the repository method breaks naming consistency across session storage interfaces.
  • Inconsistent naming for user ID-based retrieval. Similar to the shop domain issue, InMemoryUserSessionStore uses retrieve_by_shopify_user_id, while SessionRepository uses retrieve_user_session_by_shopify_user_id. The inconsistency extends to the NullUserSessionStore which uses retrieve_by_shopify_user_id but the repository adds 'session'.
  • Low CVE: [GHSA redacted] (yarn.lock)
  • Off-boarding risk: anonymized user #1
  • Orphaned file (lib/shopify_app/auth/token_exchange.rb)
  • Workflow token permissions not restricted (.github/workflows/close-waiting-for-response-issues.yml)

New (4)

  • High CVE: [GHSA redacted] (yarn.lock)
  • Off-boarding risk: anonymized user #1
  • Orphaned file (lib/shopify_app/session/shop_session_storage.rb)
  • Orphaned file (lib/shopify_app/session/user_session_storage_with_scopes.rb)

Changes since last survey

  • 11 commits — 10 feature/other, 1 fixes

By area

  • (repo) — 4 commits
  • (root) — 3 commits
  • .github/workflows — 3 commits
  • test/controllers — 1 commit

Notable commits

  • fix: Merge pull request #2098 from jsaubry/js-11-02-fix-missing-hmac-header
  • change: Merge pull request #2092 from Shopify/gardener/cleanup-dead-workflows
  • change: Merge pull request #2099 from jsaubry/js-11-02-callback-missing-oauth-params
  • change: Merge pull request #2100 from Shopify/liz/redact-token-exchange-error-log
  • change: Omit ID tokens from token exchange error logs
  • change: Redirect to login when OAuth callback params are missing
  • change: Remove gardener Slack notification and auto-labelling workflows
  • change: Remove unused gardener investigate workflow
  • change: Replace blocked issues-helper action with actions/stale in the waiting-for-response closer
  • change: Return 401 when the HMAC header is missing instead of raising
  • change: Test that a single blank OAuth callback param skips OAuth validation

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

Shopify/shopify_app was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 6 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 52bc948e49b61963d721db9c88c776d71cfe2cb5 — the exact code this score is about.
  • Scored under rubric-2026.11.2 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.2+preprod-5c4e66d9318b.