spree_doordash 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ba867fc23a044f6166e7fcb61f1641a9f3bd79ddc7c08cf1808abf20664defee
+  data.tar.gz: c3dba97527799999bcbd5cc9881b936c368a1ff819f89e4bc8cf568e7513f568
+SHA512:
+  metadata.gz: 9eccedd59afafb3bc174d769deb3cd47aa6511ca0ec4f6aec3989adab82c148928c74ba0c4416096996d1fa032f49534f1a22736292e670bcacf7ee33a1c090a
+  data.tar.gz: f5bb35207b1cfba4544b47c459c56936eb69b163c3deb3f9fd4f5322ad043b6f36b5b7a220d306037dcffa5d68967b39fac1b2bd0bc558715a41ed78aa1da034

data/.env

@@ -0,0 +1,7 @@
+# Loaded via `dotenv/load` in spec/spec_helper.rb, for the dummy test app
+# only — not read by anything that ships. Test-only Active Record Encryption
+# keys (SpreeDoordash::Credential) so specs can save/load encrypted columns;
+# generated with SecureRandom, no real secret behind them.
+ACTIVE_RECORD_ENCRYPTION_PRIMARY_KEY=CqoBmPrrhhnpIAZcvMblJed9DIzgJKP3
+ACTIVE_RECORD_ENCRYPTION_DETERMINISTIC_KEY=7xq5LaBbvEpGYbdHmtQBIItfWBjHKxgu
+ACTIVE_RECORD_ENCRYPTION_KEY_DERIVATION_SALT=AL6p4aeV1OzPeqTVpQPA8nQ4TVRA6QYH

data/.github/workflows/test.yml

@@ -0,0 +1,107 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  test-postgres:
+    name: "PostgreSQL"
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:16
+        env:
+          POSTGRES_USER: postgres
+          POSTGRES_PASSWORD: postgres
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    env:
+      DB: postgres
+      DB_HOST: localhost
+      DB_USERNAME: postgres
+      DB_PASSWORD: postgres
+      BUNDLE_JOBS: 4
+      BUNDLE_RETRY: 3
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.3'
+          bundler-cache: true
+
+      - name: Install libvips
+        run: sudo apt-get update && sudo apt-get install -y libvips-dev
+
+      - name: Create test app
+        run: bundle exec rake test_app
+
+      - name: Run tests
+        run: bundle exec rspec --format documentation
+
+  test-mysql:
+    name: "MySQL"
+    runs-on: ubuntu-latest
+    services:
+      mysql:
+        image: mysql:8.0
+        env:
+          MYSQL_ROOT_PASSWORD: password
+        ports:
+          - 3306:3306
+        options: >-
+          --health-cmd="mysqladmin ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    env:
+      DB: mysql
+      DB_HOST: 127.0.0.1
+      DB_USERNAME: root
+      DB_PASSWORD: password
+      BUNDLE_JOBS: 4
+      BUNDLE_RETRY: 3
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.3'
+          bundler-cache: true
+
+      - name: Install libvips
+        run: sudo apt-get update && sudo apt-get install -y libvips-dev
+
+      - name: Create test app
+        run: bundle exec rake test_app
+
+      - name: Run tests
+        run: bundle exec rspec --format documentation
+
+  brakeman:
+    name: Brakeman
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.3'
+          bundler-cache: true
+
+      - name: Run Brakeman
+        run: bundle exec brakeman --exit-on-warn --exit-on-error

data/.gitignore

@@ -0,0 +1,27 @@
+\#*
+*~
+.#*
+.DS_Store
+.idea
+.localeapp/locales
+.project
+.vscode
+coverage
+default
+Gemfile.lock
+tmp
+nbproject
+pkg
+*.sw?
+spec/dummy
+.rvmrc
+.sass-cache
+public/spree
+.ruby-version
+.ruby-gemset
+*.gem
+*/*.gem
+
+# Real DoorDash Sandbox credentials for manual verification — never committed,
+# unlike the test-only encryption keys in .env.
+.env.sandbox

data/.rspec

@@ -0,0 +1,3 @@
+--color
+-r spec_helper
+-f documentation

data/CHANGELOG.md

@@ -0,0 +1,54 @@
+# Changelog
+
+All notable changes to this project are documented here.
+
+## 0.1.0 (unreleased)
+
+Initial development. M1 (foundation) — complete and verified against a real DoorDash Sandbox
+endpoint (`bin/rails spree_doordash:verify_connection`, a real accepted quote):
+`SpreeDoordash::Credential` (encrypted per-store DoorDash Drive access key),
+`SpreeDoordash::Client` (JWT signing against the Drive v2 API), and a plain credential-entry
+admin form.
+
+Two real JWT-signing bugs only surfaced by that live verification, not by DoorDash's own docs or
+sample code:
+- The signing secret must be **base64url**-decoded, not standard base64.
+- The JWT header needs an explicit `typ: 'JWT'` field — the `jwt` gem doesn't add it
+  automatically the way Node's `jsonwebtoken` (what DoorDash's own sample code uses) does.
+
+M2 — `SpreeDoordash::LocationMapping` (stock location ↔ DoorDash store), `SpreeDoordash::Quote`
+(builds and persists a live delivery-fee quote for an order). Found and fixed a real ActiveRecord
+association-caching bug: creating a shipment via `create(:shipment, order:, ...)` (setting the FK
+directly) doesn't invalidate an already-loaded `order.shipments` association — fixed by querying
+`Spree::Shipment.where(order_id:)` directly rather than `order.shipments.first`.
+
+M3 — `Spree::Calculator::Shipping::DoordashQuote`, wiring a live quote into checkout as an
+ordinary shipping rate; verified end to end against a real order and a real Sandbox quote
+($9.75 for a real DC address). Two real things caught only by that live wiring:
+- `Spree::ShippingMethod.calculators` does **not** auto-discover `ShippingCalculator` subclasses —
+  it reads a hardcoded array `spree_core` populates via its own `config.after_initialize`;
+  registering the new calculator needed an explicit append in a later-running initializer.
+- Re-quoting the same order (which checkout does on essentially every step) with a stable
+  `external_delivery_id` gets rejected by DoorDash's real API with `409 duplicate_delivery_id`,
+  even though the prior quote is still open — fixed by appending a random suffix per quote
+  attempt.
+
+M4 — `SpreeDoordash::DeliveryDispatcher` (accept-or-requote-then-accept), the full webhook chain
+(`WebhooksController`, Basic-Auth `WebhookVerifier`, idempotent `WebhookEvent`,
+`DeliveryStatusMapper`). Verified live via ngrok + DoorDash's Sandbox Delivery Simulator: the full
+`DASHER_CONFIRMED` → … → `DASHER_DROPPED_OFF` event sequence, and a `DELIVERY_CANCELLED` path,
+both against real dispatched orders — confirmed `shipment.ship!` and `order.cancel!` actually
+fire on the real captured payloads. Fixed a `NOT NULL` constraint that broke
+`DeliveryDispatchJob`'s own dead-letter failure recording.
+
+M5 — Admin pages (DoorDash Deliveries, DoorDash Webhooks) and a `spree_doordash:map_location`
+rake task. Two real bugs found only by loading the pages against a real Postgres-backed app (the
+SQLite dummy app used for specs has neither problem):
+- Postgres' plain `json` type has no equality operator, and `spree_admin`'s table view issues
+  `SELECT DISTINCT` — every `json` column in this gem 500'd its own admin page. Fixed by using
+  `jsonb` on Postgres (matching `spree_core`'s own migration convention), plain `json` on SQLite.
+- `Spree.admin.tables.register` defaults to expecting a `:new` route that doesn't exist on a
+  read-only resource — 500'd the instant a table was empty. Fixed with `new_resource: false`.
+
+⚠️ DoorDash Drive API production access is currently restricted by DoorDash (no committed
+timeline) — this extension targets and is verified against **Sandbox** only until that changes.

data/CONTRIBUTING.md

@@ -0,0 +1,29 @@
+# Contributing
+
+Thanks for considering a contribution to `spree_doordash`.
+
+## Getting set up
+
+```bash
+bundle install
+bundle exec rake test_app   # generates spec/dummy, the Rails app specs run against
+bundle exec rspec
+```
+
+## Making a change
+
+1. Open an issue first for anything beyond a small fix, so the approach can be discussed before
+   you put time into it.
+2. Add or update specs alongside any behavior change — `bundle exec rspec` should stay green.
+3. Keep decorators as a last resort (see the main README's customization pattern order); prefer
+   Spree's Events/Subscribers or Dependencies mechanisms where they fit.
+4. Open a pull request describing what changed and why.
+
+## Releasing (maintainers)
+
+```bash
+bundle exec gem bump --version [major|minor|patch] -t -m "Release v%s"
+bundle exec gem release
+```
+
+See the [gem-release README](https://github.com/svenfuchs/gem-release) for more options.

data/Gemfile

@@ -0,0 +1,27 @@
+source 'https://rubygems.org'
+
+gem 'rails-controller-testing'
+
+# Pinned to the released 5.6.x line (matching spree_host), same rationale as
+# spree_square's Gemfile.
+spree_opts = if ENV['SPREE_PATH']
+                { 'path': ENV['SPREE_PATH'] }
+             else
+                '~> 5.6.0'
+             end
+gem 'spree', spree_opts
+gem 'spree_admin', spree_opts
+
+gem 'spree_dev_tools', '>= 0.6.0.rc1'
+
+if ENV['DB'] == 'mysql'
+  gem 'mysql2'
+elsif ENV['DB'] == 'postgres'
+  gem 'pg'
+else
+  gem 'sqlite3'
+end
+
+gem 'propshaft'
+
+gemspec

data/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Amit Solanki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,109 @@
+# Spree DoorDash
+
+[![Gem Version](https://img.shields.io/gem/v/spree_doordash.svg)](https://rubygems.org/gems/spree_doordash)
+[![GitHub Release](https://img.shields.io/github/v/release/amitkssolanki/spree_doordash)](https://github.com/amitkssolanki/spree_doordash/releases)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE.md)
+
+This is a [DoorDash Drive](https://developer.doordash.com) delivery extension for [Spree Commerce](https://spreecommerce.org), an open source e-commerce platform built with Ruby on Rails. It's the companion to [`spree_square`](https://github.com/amitkssolanki/spree_square) — quotes and dispatches DoorDash Drive deliveries for completed Spree orders, keyed off each order's fulfilling location.
+
+> ⚠️ **DoorDash Drive API production access is currently restricted by DoorDash**, with no committed timeline — see their [Get Started guide](https://developer.doordash.com/en-US/docs/drive/tutorials/get_started/). Sandbox is fully open, and this extension's entire flow (live quoting, dispatch, webhook-driven status sync, admin diagnostics) is built and verified end to end against Sandbox — including DoorDash's own [Delivery Simulator](https://developer.doordash.com) — without ever needing production approval. Going live requires DoorDash's separate approval on their own timeline.
+
+## What this does
+
+- **Live delivery-fee quoting at checkout** — `Spree::Calculator::Shipping::DoordashQuote` requests
+  a real DoorDash quote and shows it as an ordinary shipping rate, no custom storefront code
+  needed.
+- **Dispatch on order completion** — accepts the checkout-time quote (re-quoting first if it's
+  expired; DoorDash quotes are only valid 5 minutes) and creates the real delivery.
+- **Delivery status synced back via webhooks** — a Dasher picking up/dropping off/canceling the
+  order updates the Spree shipment/order state automatically.
+- **Admin visibility** — DoorDash Deliveries and DoorDash Webhooks pages for support/diagnostics.
+
+## Installation
+
+1. Add this extension to your Gemfile with this line:
+
+    ```ruby
+    bundle add spree_doordash
+    ```
+
+2. Run the install generator
+
+    ```ruby
+    bundle exec rails g spree_doordash:install
+    ```
+
+3. Restart your server
+
+  If your server was running, restart it so that it can find the assets properly.
+
+## Connecting to DoorDash
+
+DoorDash Drive auth has no OAuth/refresh flow — a static access key, created once, signs a fresh
+short-lived JWT on every API call:
+
+1. Create a [DoorDash Developer Portal](https://developer.doordash.com) account and create an
+   access key (**Credentials** in the left nav). This gives you a `developer_id`, `key_id`, and
+   `signing_secret`.
+2. In your Spree admin, go to **DoorDash Connection** in the sidebar and paste the three values
+   in. They're encrypted at rest ([ActiveRecord::Encryption](https://guides.rubyonrails.org/active_record_encryption.html)) —
+   same mechanism `spree_square` uses for its own credentials, sharing the same
+   `ACTIVE_RECORD_ENCRYPTION_*` keys.
+3. Configure a webhook endpoint for delivery status updates in the Developer Portal's
+   **Webhooks** page (Sandbox and Production each support one endpoint), protected with Basic
+   Auth. Paste that exact `Authorization` header value into the **Webhook Basic Auth value**
+   field on the same connection page — it's a static string DoorDash echoes back verbatim on
+   every webhook, not a credential DoorDash itself authenticates.
+4. Point the webhook URL at `POST /spree_doordash/webhooks/doordash` on your store (needs to be
+   internet-reachable — `ngrok`/`cloudflared` for local dev).
+
+Access keys created before requesting production access are Sandbox-only — you can build and
+fully test this extension's entire flow (quotes, dispatch, status webhooks, DoorDash's own
+[Delivery Simulator](https://developer.doordash.com)) without ever needing production approval.
+
+## Setting up a DoorDash Delivery shipping method
+
+1. Map each fulfilling stock location to a DoorDash store:
+
+    ```bash
+    bin/rails "spree_doordash:map_location[stock_location_id_or_name,doordash_store_id,doordash_business_id]"
+    ```
+
+    `doordash_business_id` defaults to `"default"` — DoorDash Sandbox auto-assigns a default
+    business/store to every access key, so that's normally all you need there.
+
+2. In **Settings → Shipping Methods**, create a new shipping method (e.g. "DoorDash Delivery")
+   with calculator **DoordashQuote**, attached to whichever zone/shipping category your delivery
+   orders use. `Spree::Stock::Estimator` picks it up automatically — no further wiring needed;
+   any code path that estimates shipping rates for an order (checkout, admin, API) will now
+   request a live quote for that rate whenever the order has a ship address.
+
+## Development
+
+```bash
+bundle install
+bundle exec rake test_app   # generates spec/dummy
+bundle exec rspec
+```
+
+When testing your application's integration with this extension you may use its factories.
+Simply add this require statement to your spec_helper:
+
+```ruby
+require 'spree_doordash/factories'
+```
+
+## Releasing a new version
+
+```shell
+bundle exec gem bump -p -t
+bundle exec gem release
+```
+
+For more options please see [gem-release README](https://github.com/svenfuchs/gem-release)
+
+## Contributing
+
+If you'd like to contribute, please take a look at the
+[instructions](CONTRIBUTING.md) for installing dependencies and crafting a good
+pull request.

data/Rakefile

@@ -0,0 +1,23 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'spree/testing_support/extension_rake'
+
+RSpec::Core::RakeTask.new
+
+task :default do
+  if Dir['spec/dummy'].empty?
+    Rake::Task[:test_app].invoke
+    Dir.chdir('../../')
+  end
+  Rake::Task[:spec].invoke
+end
+
+desc 'Generates a dummy app for testing'
+task :test_app do
+  ENV['LIB_NAME'] = 'spree_doordash'
+  Rake::Task['extension:test_app'].execute(
+    install_admin: true
+  )
+end

data/app/controllers/spree/admin/doordash_credentials_controller.rb

@@ -0,0 +1,42 @@
+module Spree
+  module Admin
+    # Plain credential-entry form for the current store's DoorDash Drive
+    # access key — not an OAuth connect/disconnect flow like Square's.
+    # DoorDash Drive auth has no redirect dance: an admin creates an access
+    # key once in DoorDash's Developer Portal and pastes the three values in
+    # here directly (encrypted at rest — see SpreeDoordash::Credential).
+    class DoordashCredentialsController < Spree::Admin::BaseController
+      def show
+        @credential = SpreeDoordash::Credential.find_or_initialize_by(store: current_store)
+      end
+
+      def update
+        @credential = SpreeDoordash::Credential.find_or_initialize_by(store: current_store)
+
+        if @credential.update(credential_params)
+          flash[:success] = Spree.t(:doordash_credential_saved, default: 'DoorDash credentials saved.')
+        else
+          flash[:error] = @credential.errors.full_messages.to_sentence
+        end
+
+        redirect_to admin_doordash_credential_path
+      end
+
+      private
+
+      # Blank secret fields mean "leave unchanged" (the form always renders
+      # them empty and never echoes the current value back) — submitting an
+      # actually-blank value would otherwise silently overwrite a working
+      # credential with an empty string on every save.
+      def credential_params
+        permitted = params.require(:spree_doordash_credential).permit(
+          :developer_id, :key_id, :signing_secret, :webhook_basic_auth_token, :doordash_environment
+        )
+        %i[signing_secret webhook_basic_auth_token].each do |field|
+          permitted.delete(field) if permitted[field].blank?
+        end
+        permitted
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/doordash_delivery_mappings_controller.rb

@@ -0,0 +1,12 @@
+module Spree
+  module Admin
+    # Read-only support/diagnostic view — no create/edit/destroy, this is
+    # visibility into what spree_doordash has already dispatched, not a
+    # place to change it. See config/routes.rb (only: [:index]).
+    class DoordashDeliveryMappingsController < ResourceController
+      def model_class
+        SpreeDoordash::DeliveryMapping
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/doordash_webhook_events_controller.rb

@@ -0,0 +1,11 @@
+module Spree
+  module Admin
+    # Read-only support/diagnostic view of every inbound DoorDash webhook —
+    # what arrived, whether it processed, and the error if it didn't.
+    class DoordashWebhookEventsController < ResourceController
+      def model_class
+        SpreeDoordash::WebhookEvent
+      end
+    end
+  end
+end

data/app/controllers/spree_doordash/webhooks_controller.rb

@@ -0,0 +1,60 @@
+module SpreeDoordash
+  # Receives DoorDash Drive webhook notifications. Basic-Auth-verified
+  # instead of Square's HMAC signature (see SpreeDoordash::WebhookVerifier)
+  # and, like SpreeSquare::WebhooksController, deliberately does the least
+  # possible work synchronously: verify, record, ack, hand off to a job.
+  # DoorDash "sends each webhook event up to 3 times" on anything other
+  # than 200 (its own docs), so a slow or non-2xx response means retries.
+  class WebhooksController < ActionController::Base
+    # Explicit, not just `skip_before_action :verify_authenticity_token` —
+    # this controller doesn't inherit the host app's ApplicationController
+    # (where `protect_from_forgery` normally gets declared), so a static
+    # analyzer (Brakeman) correctly flags it as never actually configured
+    # either way — confirmed by the identical warning on spree_square's own
+    # WebhooksController. `:null_session` degrades a forged/missing token
+    # to an empty session instead of raising — appropriate here since this
+    # endpoint is Basic-Auth-verified, not session-authenticated.
+    protect_from_forgery with: :null_session
+
+    def create
+      credential = SpreeDoordash::Credential.find_by(store: Spree::Store.default)
+
+      unless SpreeDoordash::WebhookVerifier.valid?(
+        authorization_header: request.headers['Authorization'],
+        expected_token: credential&.webhook_basic_auth_token
+      )
+        Rails.logger.warn('[SpreeDoordash] webhook auth verification failed')
+        return head :unauthorized
+      end
+
+      raw_body = request.raw_post
+      payload = JSON.parse(raw_body)
+      event = find_or_log_event(raw_body, payload)
+      SpreeDoordash::DeliveryWebhookJob.perform_later(event.id) if event.previously_new_record?
+
+      head :ok
+    rescue JSON::ParserError
+      head :bad_request
+    end
+
+    private
+
+    def find_or_log_event(raw_body, payload)
+      SpreeDoordash::WebhookEvent.find_or_create_by!(
+        external_delivery_id: payload['external_delivery_id'],
+        event_name: payload['event_name'],
+        payload_digest: SpreeDoordash::WebhookEvent.digest(raw_body)
+      ) do |event|
+        event.payload = payload
+      end
+    rescue ActiveRecord::RecordNotUnique, ActiveRecord::RecordInvalid
+      # Lost a race with a concurrent duplicate delivery — the row exists
+      # now either way, and it's already being (or has been) processed once.
+      SpreeDoordash::WebhookEvent.find_by!(
+        external_delivery_id: payload['external_delivery_id'],
+        event_name: payload['event_name'],
+        payload_digest: SpreeDoordash::WebhookEvent.digest(raw_body)
+      )
+    end
+  end
+end

data/app/jobs/spree_doordash/base_job.rb

@@ -0,0 +1,5 @@
+module SpreeDoordash
+  class BaseJob < Spree::BaseJob
+    queue_as SpreeDoordash.queue
+  end
+end

data/app/jobs/spree_doordash/delivery_dispatch_job.rb

@@ -0,0 +1,22 @@
+module SpreeDoordash
+  # A failed dispatch is the worst failure mode in this whole extension —
+  # payment already taken, kitchen already has the ticket (spree_square's
+  # own push is independent), but no one is actually coming to pick it up.
+  # Same retry/dead-letter/Alerting shape as SpreeSquare::OrderPushJob for
+  # exactly that reason.
+  class DeliveryDispatchJob < BaseJob
+    retry_on StandardError, wait: :polynomially_longer, attempts: 5 do |job, error|
+      order = Spree::Order.find_by(id: job.arguments.first)
+      SpreeDoordash::DeliveryMapping.find_or_initialize_by(order: order).mark_failed!(error) if order
+      SpreeDoordash::Alerting.capture(
+        error,
+        context: { area: 'delivery_dispatch', order_number: order&.number }
+      )
+    end
+
+    def perform(order_id)
+      order = Spree::Order.find(order_id)
+      SpreeDoordash::DeliveryDispatcher.call(order)
+    end
+  end
+end

data/app/jobs/spree_doordash/delivery_webhook_job.rb

@@ -0,0 +1,17 @@
+module SpreeDoordash
+  # Applies one already-verified, already-deduplicated DoorDash webhook
+  # event to the order it's mapped to. Same retry/dead-letter/Alerting
+  # shape as every other webhook-handling job in this codebase.
+  class DeliveryWebhookJob < BaseJob
+    retry_on StandardError, wait: :polynomially_longer, attempts: 5 do |job, error|
+      SpreeDoordash::WebhookEvent.find_by(id: job.arguments.first)&.mark_failed!(error)
+      SpreeDoordash::Alerting.capture(error, context: 'delivery_webhook')
+    end
+
+    def perform(webhook_event_id)
+      event = SpreeDoordash::WebhookEvent.find(webhook_event_id)
+      SpreeDoordash::DeliveryStatusMapper.call(event.payload)
+      event.mark_processed!
+    end
+  end
+end

data/app/models/spree/calculator/shipping/doordash_quote.rb

@@ -0,0 +1,40 @@
+require_dependency 'spree/shipping_calculator'
+
+module Spree
+  # Compact `module Calculator::Shipping` (not separately-nested `module
+  # Calculator; module Shipping`) — Spree::Calculator is already a class,
+  # not a module, in spree_core; nesting it that way raises `TypeError:
+  # Calculator is not a module`. This is the exact form spree_core's own
+  # calculators (e.g. Spree::Calculator::Shipping::FlatRate) use.
+  module Calculator::Shipping
+    # Prices a "DoorDash Delivery" shipping method against a real, live
+    # DoorDash Drive quote rather than a flat/configured rate.
+    # Spree::Stock::Estimator calls `calculator.compute(package)`, which
+    # Spree::Calculator#compute dispatches to `compute_package` by
+    # demodulizing the argument's class name (Spree::Stock::Package ->
+    # "package") — no override of #compute itself needed.
+    class DoordashQuote < ShippingCalculator
+      def self.description
+        'DoorDash Drive (live quote)'
+      end
+
+      def compute_package(package)
+        result = SpreeDoordash::Quote.call(package.order)
+        return nil unless result
+
+        result.fee_cents / 100.0
+      end
+
+      # Called by Estimator to filter which shipping methods even attempt
+      # a compute_package call. Skips the DoorDash API round-trip entirely
+      # for an order with no ship address yet (early checkout, before
+      # Estimator would sensibly be asked at all) — the real "can DoorDash
+      # serve this address" check still happens inside SpreeDoordash::Quote
+      # itself (compute_package returning nil is what actually makes the
+      # rate not show up).
+      def available?(package)
+        package.order.ship_address.present?
+      end
+    end
+  end
+end

data/app/models/spree_doordash/credential.rb

@@ -0,0 +1,23 @@
+module SpreeDoordash
+  # A DoorDash Drive access key + webhook secret for one Spree::Store.
+  # Unlike SpreeSquare::Credential, this isn't an OAuth connection — DoorDash
+  # Drive auth is a static access key (developer_id/key_id/signing_secret),
+  # created once in DoorDash's Developer Portal and entered directly here,
+  # used to sign a fresh short-lived JWT per API call (see
+  # SpreeDoordash::Client). No refresh flow, so no expires_at/needs_refresh?
+  # the way Square's Credential has.
+  class Credential < Spree.base_class
+    self.table_name = 'spree_doordash_credentials'
+
+    belongs_to :store, class_name: 'Spree::Store'
+
+    encrypts :developer_id, :key_id, :signing_secret, :webhook_basic_auth_token
+
+    validates :store, presence: true, uniqueness: true
+    validates :developer_id, :key_id, :signing_secret, presence: true
+
+    def sandbox?
+      doordash_environment == 'sandbox'
+    end
+  end
+end