instagram_connect 0.2.0 → 0.3.0

data/app/models/instagram_connect/conversation.rb

@@ -2,12 +2,21 @@ module InstagramConnect
   # One DM thread — a connected account talking to one Instagram user (igsid).
   # Threads are shared across the host's operators; ownership lives on the
   # account, not per-operator.
+  #
+  # Every writer here is SQL-side and monotonic. Meta guarantees no ordering
+  # across webhook batches, so a late-arriving older event must not roll a
+  # thread backwards, and concurrent inbound writes must not lose an unread
+  # increment.
   class Conversation < ApplicationRecord
     self.table_name = "instagram_connect_conversations"
 
+    FOLDERS = %w[primary general requests].freeze
+
     belongs_to :account, class_name: "InstagramConnect::Account"
     has_many :messages, class_name: "InstagramConnect::Message",
              foreign_key: :conversation_id, dependent: :destroy
+    has_many :reactions, class_name: "InstagramConnect::MessageReaction",
+             foreign_key: :conversation_id, dependent: :destroy
 
     validates :igsid, presence: true, uniqueness: { scope: :account_id }
 
@@ -23,21 +32,100 @@ module InstagramConnect
 
     # Denormalizes the thread summary + unread count atomically (SQL-side) so
     # concurrent inbound writes can't lose an unread increment.
+    #
+    # Keyed on the message's wire time, not our created_at: a webhook batch
+    # delayed by a redeploy would otherwise stamp old messages as the newest
+    # and reorder the inbox.
     def register_message(message)
-      stamp = message.created_at || Time.current
+      stamp = message.sent_at || message.created_at || Time.current
+      assignments = [
+        "last_message_at = #{monotonic('last_message_at')}",
+        "last_message_preview = ?",
+        "last_event_at = #{monotonic('last_event_at')}"
+      ]
+      binds = [ stamp, stamp, message.preview, stamp, stamp ]
+
       if message.inbound?
-        self.class.where(id: id).update_all([
-          "last_message_at = ?, last_message_preview = ?, last_inbound_at = ?, " \
-          "unread_count = unread_count + 1, updated_at = ?",
-          stamp, message.preview, stamp, Time.current
-        ])
-      else
-        self.class.where(id: id).update_all([
-          "last_message_at = ?, last_message_preview = ?, updated_at = ?",
-          stamp, message.preview, Time.current
-        ])
+        assignments << "last_inbound_at = #{monotonic('last_inbound_at')}"
+        assignments << "unread_count = unread_count + 1"
+        binds += [ stamp, stamp ]
       end
+
+      apply(assignments, binds)
+    end
+
+    # A read receipt only ever moves forward. A stale one redelivered after a
+    # newer message must not mark the thread read again.
+    def mark_read_by_customer(at:, mid: nil)
+      apply(
+        [
+          "customer_last_read_mid = CASE WHEN customer_last_read_at IS NULL " \
+          "OR customer_last_read_at < ? THEN ? ELSE customer_last_read_mid END",
+          "customer_last_read_at = #{monotonic('customer_last_read_at')}",
+          "last_event_at = #{monotonic('last_event_at')}"
+        ],
+        [ at, mid, at, at, at, at ]
+      )
+      mark_outbound_seen(at)
+      self
+    end
+
+    def register_referral(ref:, at:)
+      apply(
+        [
+          "last_referral_ref = CASE WHEN last_event_at IS NULL OR last_event_at < ? " \
+          "THEN ? ELSE last_referral_ref END",
+          "last_event_at = #{monotonic('last_event_at')}"
+        ],
+        [ at, ref, at, at ]
+      )
+    end
+
+    def register_thread_control(owner_app_id:, at:)
+      apply(
+        [
+          "thread_owner_app_id = CASE WHEN thread_control_at IS NULL OR thread_control_at < ? " \
+          "THEN ? ELSE thread_owner_app_id END",
+          "thread_control_at = #{monotonic('thread_control_at')}",
+          "last_event_at = #{monotonic('last_event_at')}"
+        ],
+        [ at, owner_app_id, at, at, at, at ]
+      )
+    end
+
+    # Any activity that is not a message — a reaction, an opt-in — still counts
+    # as the thread being alive, and still reopens Meta's 24-hour window.
+    def register_event(at)
+      apply([ "last_event_at = #{monotonic('last_event_at')}" ], [ at, at ])
+    end
+
+    # True when another app (typically the Page Inbox) holds thread control, in
+    # which case the Send API rejects our messages.
+    def controlled_elsewhere?
+      thread_control_at.present? && thread_owner_app_id.present?
+    end
+
+    private
+
+    # SQLite has no GREATEST, so the monotonic guard is spelled as a CASE. Two
+    # binds per use: the comparison value and the value to store.
+    def monotonic(column)
+      "CASE WHEN #{column} IS NULL OR #{column} < ? THEN ? ELSE #{column} END"
+    end
+
+    def apply(assignments, binds)
+      self.class.where(id: id).update_all(
+        [ "#{assignments.join(', ')}, updated_at = ?", *binds, Time.current ]
+      )
       reload
     end
+
+    # The receipt covers everything the customer had received, so every earlier
+    # outbound message is seen too — Meta sends one receipt, not one per bubble.
+    def mark_outbound_seen(at)
+      messages.where(direction: "outbound", seen_at: nil)
+              .where(sent_at: ..at)
+              .update_all(seen_at: at, updated_at: Time.current)
+    end
   end
 end

data/app/models/instagram_connect/inbound_message.rb

@@ -1,10 +1,18 @@
 module InstagramConnect
-  # At-least-once dedupe ledger keyed by Meta's message id. Lets the webhook
-  # (and any future backfill/poll) run without double-processing a message.
+  # Dedupe ledger keyed by Meta's message id, scoped to an account.
+  #
+  # DEPRECATED, removal at 1.0. WebhookEvent is the claim now: keying every
+  # event type on one message id is wrong once other fields carry the same id —
+  # a messaging_seen receipt names the mid of a message already claimed here, so
+  # claiming it would swallow either the receipt or the message. This is kept in
+  # step so a host querying it against 0.2.x behaviour still sees every message.
   class InboundMessage < ApplicationRecord
     self.table_name = "instagram_connect_inbound_messages"
 
-    # Returns true only the first time a given message id is claimed.
+    # Returns true only the first time a message id is claimed for an account.
+    # Uniqueness is scoped per account: two connected accounts messaging each
+    # other share a mid, and a global claim would drop it for whichever account
+    # processed second. A nil account_id therefore no longer dedupes at all.
     def self.claim(ig_message_id:, account_id: nil)
       create!(ig_message_id: ig_message_id, account_id: account_id, processed_at: Time.current)
       true

data/app/models/instagram_connect/insight_snapshot.rb

@@ -0,0 +1,43 @@
+module InstagramConnect
+  # One reading of a set of metrics, kept because Meta's own retention is short
+  # and, for stories, measured in hours.
+  class InsightSnapshot < ApplicationRecord
+    self.table_name = "instagram_connect_insight_snapshots"
+
+    SUBJECT_TYPES = %w[account media story].freeze
+    SOURCES = %w[api webhook].freeze
+
+    belongs_to :account, class_name: "InstagramConnect::Account"
+
+    validates :subject_type, inclusion: { in: SUBJECT_TYPES }
+    validates :source, inclusion: { in: SOURCES }
+    validates :period, :period_start, :captured_at, presence: true
+
+    scope :for_subject, ->(type, ref) { where(subject_type: type, subject_ref: ref) }
+    scope :chronological, -> { order(:period_start, :id) }
+
+    # Upsert on the natural key. The API poller overwrites its own reading as a
+    # story accrues views; the webhook's final reading is a separate row because
+    # source is part of the key, so neither can clobber the other.
+    def self.record(account:, subject_type:, period:, period_start:, metrics:, captured_at:,
+                    subject_ref: nil, breakdown: nil, source: "api", empty: false,
+                    suppressed: false, error_code: nil)
+      snapshot = find_or_initialize_by(
+        account_id: account.id, subject_type: subject_type, subject_ref: subject_ref,
+        period: period, period_start: period_start, breakdown: breakdown, source: source
+      )
+      snapshot.assign_attributes(
+        metrics: metrics, captured_at: captured_at, empty: empty,
+        suppressed: suppressed, error_code: error_code
+      )
+      snapshot.save!
+      snapshot
+    end
+
+    # nil means Meta did not report the metric, which is not the same as zero —
+    # so callers must never reach for a default here.
+    def value(metric)
+      metrics.is_a?(Hash) ? metrics[metric.to_s] : nil
+    end
+  end
+end

data/app/models/instagram_connect/media_item.rb

@@ -0,0 +1,38 @@
+module InstagramConnect
+  # A post, reel or story on the connected account — "IG Media" in Meta's
+  # vocabulary. Named MediaItem because InstagramConnect::Media is already the
+  # namespace for inbound file handling (Media::Limits, Media::Attaching); the
+  # table keeps Meta's noun.
+  class MediaItem < ApplicationRecord
+    self.table_name = "instagram_connect_media"
+
+    PRODUCT_TYPES = %w[FEED STORY REELS AD].freeze
+
+    belongs_to :account, class_name: "InstagramConnect::Account"
+    has_many :insight_snapshots, -> { where(subject_type: "media") },
+             class_name: "InstagramConnect::InsightSnapshot",
+             foreign_key: :subject_ref, primary_key: :ig_media_id,
+             dependent: :destroy, inverse_of: false
+
+    validates :ig_media_id, presence: true, uniqueness: { scope: :account_id }
+
+    scope :stories, -> { where(media_product_type: "STORY") }
+    scope :recent, -> { order(Arel.sql("posted_at IS NULL, posted_at DESC")) }
+
+    # Upserts by Meta's id. Media arrives from several directions — a webhook
+    # about a comment, a story expiring, a sync — and whichever gets there first
+    # should create the row without the others having to care.
+    def self.record(account:, ig_media_id:, **attributes)
+      media = find_or_initialize_by(account_id: account.id, ig_media_id: ig_media_id.to_s)
+      media.assign_attributes(attributes.compact)
+      media.save!
+      media
+    rescue ActiveRecord::RecordNotUnique
+      find_by!(account_id: account.id, ig_media_id: ig_media_id.to_s)
+    end
+
+    def story?
+      media_product_type == "STORY"
+    end
+  end
+end

data/app/models/instagram_connect/mention.rb

@@ -0,0 +1,37 @@
+module InstagramConnect
+  # An @mention of the account, in a comment, a caption or a tag.
+  #
+  # Meta does not store these notifications and will not resend them, so this
+  # table is the only record that a mention ever happened.
+  class Mention < ApplicationRecord
+    self.table_name = "instagram_connect_mentions"
+
+    KINDS = %w[comment caption tag story].freeze
+
+    belongs_to :account, class_name: "InstagramConnect::Account"
+    belongs_to :message, class_name: "InstagramConnect::Message", optional: true
+
+    validates :kind, inclusion: { in: KINDS }
+    validates :mentioned_at, presence: true
+
+    scope :unanswered, -> { where(replied_at: nil) }
+    scope :recent, -> { order(mentioned_at: :desc) }
+
+    def self.record(account:, kind:, mentioned_at:, ig_media_id: nil, comment_id: nil, **attributes)
+      mention = find_or_initialize_by(
+        account_id: account.id, kind: kind,
+        ig_media_id: ig_media_id.presence, comment_id: comment_id.presence
+      )
+      mention.assign_attributes(attributes.compact.merge(mentioned_at: mentioned_at))
+      mention.save!
+      mention
+    rescue ActiveRecord::RecordNotUnique
+      find_by!(account_id: account.id, kind: kind,
+               ig_media_id: ig_media_id.presence, comment_id: comment_id.presence)
+    end
+
+    def answered?
+      replied_at.present?
+    end
+  end
+end

data/app/models/instagram_connect/message.rb

@@ -5,12 +5,21 @@ module InstagramConnect
 
     DIRECTIONS = %w[inbound outbound].freeze
     STATUSES = %w[received pending sending sent failed].freeze
-    KINDS = %w[dm story_reply reaction].freeze
+    KINDS = %w[dm story_reply story_mention reaction postback share unsupported].freeze
     SOURCES = %w[inbound manual api operator_app].freeze
     MEDIA_STATUSES = %w[none pending downloadable attached unavailable].freeze
     PREVIEW_LIMIT = 140
 
     belongs_to :conversation, class_name: "InstagramConnect::Conversation"
+    # Denormalized from the conversation so account-scoped queries and stream
+    # names do not need a join, and so uniqueness can be scoped per account.
+    before_validation :inherit_account_id
+
+    has_many :attachments, -> { order(:position) },
+             class_name: "InstagramConnect::MessageAttachment",
+             foreign_key: :message_id, dependent: :destroy
+    has_many :reactions, class_name: "InstagramConnect::MessageReaction",
+             foreign_key: :message_id, dependent: :nullify
 
     validates :direction, inclusion: { in: DIRECTIONS }
     validates :status, inclusion: { in: STATUSES }
@@ -18,7 +27,24 @@ module InstagramConnect
 
     scope :inbound, -> { where(direction: "inbound") }
     scope :outbound, -> { where(direction: "outbound") }
-    scope :chronological, -> { order(:created_at, :id) }
+    # Ordered by Meta's clock, falling back to ours for rows written before
+    # sent_at existed. A webhook batch delayed by a redeploy would otherwise
+    # reorder the thread.
+    scope :chronological, -> { order(Arel.sql("COALESCE(sent_at, created_at)"), :id) }
+
+    # Extension point: a host rendering this record live overrides it to
+    # re-broadcast current state after a callback-free write (update_all, which
+    # the send and media paths both use to stay atomic). A no-op here keeps the
+    # gem free of any Turbo dependency.
+    def broadcast_refresh; end
+
+    def occurred_at
+      sent_at || created_at
+    end
+
+    def deleted?
+      deleted_at.present?
+    end
 
     def inbound?
       direction == "inbound"
@@ -33,5 +59,11 @@ module InstagramConnect
       return body.to_s.truncate(PREVIEW_LIMIT) if body.present?
       "[#{kind}]"
     end
+
+    private
+
+    def inherit_account_id
+      self.account_id ||= conversation&.account_id
+    end
   end
 end

data/app/models/instagram_connect/message_attachment.rb

@@ -0,0 +1,53 @@
+module InstagramConnect
+  # One file on a message. Rows are created at ingest with everything already
+  # decided except the bytes, which a job fetches separately.
+  class MessageAttachment < ApplicationRecord
+    self.table_name = "instagram_connect_message_attachments"
+
+    # Instagram gives no second chance at inbound media: the CDN URL expires and
+    # there is no endpoint to ask again. So there is no "downloadable" state
+    # here as there is for transports that keep the file — an attachment either
+    # lands in storage or is permanently unavailable.
+    STATES = %w[pending attached unavailable skipped].freeze
+
+    # Meta's own vocabulary for what the attachment is, which is not the same
+    # question as what MIME type the bytes turn out to be.
+    KINDS = %w[image video audio file share story_mention ig_reel reel template].freeze
+
+    belongs_to :message, class_name: "InstagramConnect::Message"
+
+
+    validates :position, presence: true, uniqueness: { scope: :message_id }
+    validates :kind, presence: true
+    validates :state, inclusion: { in: STATES }
+
+    # Called from the engine's to_prepare when Active Storage is present, the
+    # same shape as Account.enable_token_encryption!. The gem does not depend on
+    # Active Storage, so a host without it still boots and simply keeps the
+    # attachment rows as metadata without ever fetching bytes.
+    def self.enable_file_attachment!
+      has_one_attached :file
+    end
+
+    scope :pending, -> { where(state: "pending") }
+    scope :ordered, -> { order(:position) }
+
+    def fetchable?
+      state == "pending" && source_url.present?
+    end
+
+    def attached?
+      state == "attached"
+    end
+
+    def mark_attached!(mime:, size:, filename: nil)
+      update!(state: "attached", mime: mime, size: size, filename: filename, error: nil)
+    end
+
+    # Terminal. Nothing retries after this, because retrying a URL Instagram has
+    # already expired only burns the rate budget.
+    def mark_unavailable!(reason)
+      update!(state: "unavailable", error: reason.to_s.truncate(255))
+    end
+  end
+end

data/app/models/instagram_connect/message_reaction.rb

@@ -0,0 +1,33 @@
+module InstagramConnect
+  # One reaction event on a message. Append-only — see the migration for why
+  # current state is a read rather than a column.
+  class MessageReaction < ApplicationRecord
+    self.table_name = "instagram_connect_message_reactions"
+
+    ACTIONS = %w[react unreact].freeze
+    ACTORS = %w[customer business].freeze
+
+    belongs_to :conversation, class_name: "InstagramConnect::Conversation"
+    belongs_to :message, class_name: "InstagramConnect::Message", optional: true
+
+    validates :ig_message_id, :igsid, :reacted_at, presence: true
+    validates :action, inclusion: { in: ACTIONS }
+    validates :actor, inclusion: { in: ACTORS }
+
+    scope :chronological, -> { order(:reacted_at, :id) }
+
+    # The reaction currently showing on a message, or nil if the last event was
+    # an unreact. Reading MAX(reacted_at) rather than trusting arrival order is
+    # what makes out-of-order delivery harmless.
+    def self.current_for(ig_message_id)
+      latest = where(ig_message_id: ig_message_id).chronological.last
+      return nil if latest.nil? || latest.action == "unreact"
+
+      latest
+    end
+
+    def react?
+      action == "react"
+    end
+  end
+end

data/app/models/instagram_connect/webhook_event.rb

@@ -0,0 +1,67 @@
+module InstagramConnect
+  # One row per webhook event Meta delivered, stored verbatim before anything
+  # interprets it. See the migration for why this exists rather than a counter.
+  class WebhookEvent < ApplicationRecord
+    self.table_name = "instagram_connect_webhook_events"
+
+    STATUSES = %w[pending processed unhandled failed].freeze
+
+    belongs_to :account, class_name: "InstagramConnect::Account", optional: true
+    belongs_to :subject, polymorphic: true, optional: true
+
+    validates :field, :event_type, :dedupe_key, presence: true
+    validates :status, inclusion: { in: STATUSES }
+
+    scope :pending, -> { where(status: "pending") }
+    scope :replayable, -> { where(status: %w[pending unhandled failed]) }
+    scope :for_field, ->(field) { where(field: field) }
+    scope :chronological, -> { order(:occurred_at, :id) }
+
+    # Claims an event for processing, or returns nil if this exact event was
+    # already delivered. Meta retries webhooks it considers unacknowledged, so
+    # duplicates are routine rather than exceptional — the unique index on
+    # [field, dedupe_key] is what makes the claim atomic under concurrency.
+    def self.claim(field:, dedupe_key:, event_type:, payload:, account: nil,
+                   object: nil, entry_id: nil, occurred_at: nil, handler: nil)
+      create!(
+        account: account,
+        object: object,
+        field: field,
+        event_type: event_type,
+        dedupe_key: dedupe_key,
+        entry_id: entry_id,
+        occurred_at: occurred_at,
+        received_at: Time.current,
+        handler: handler,
+        payload: payload,
+        status: "pending"
+      )
+    rescue ActiveRecord::RecordNotUnique
+      nil
+    end
+
+    def mark_processed!(subject = nil)
+      update!(status: "processed", processed_at: Time.current, subject: subject)
+    end
+
+    # Recorded, not dropped: a field the gem does not parse yet is still worth
+    # keeping, because replaying it later is the only way to recover events Meta
+    # will never send again.
+    def mark_unhandled!
+      update!(status: "unhandled", processed_at: Time.current)
+    end
+
+    def mark_failed!(error)
+      update!(
+        status: "failed",
+        processed_at: Time.current,
+        error_class: error.class.name,
+        error_message: error.message.to_s.truncate(1000)
+      )
+    end
+
+    def processed?
+      status == "processed"
+    end
+  end
+end

data/db/migrate/20260715072548_create_instagram_connect_accounts.rb

@@ -1,6 +1,6 @@
 class CreateInstagramConnectAccounts < ActiveRecord::Migration[7.1]
   def change
-    create_table :instagram_connect_accounts do |t|
+    create_table :instagram_connect_accounts, if_not_exists: true do |t|
       t.string :auth_path, null: false
       t.string :ig_user_id, null: false
       t.string :page_id
@@ -11,6 +11,6 @@ class CreateInstagramConnectAccounts < ActiveRecord::Migration[7.1]
       t.bigint :connected_by_id
       t.timestamps
     end
-    add_index :instagram_connect_accounts, :ig_user_id, unique: true
+    add_index :instagram_connect_accounts, :ig_user_id, unique: true, if_not_exists: true
   end
 end

data/db/migrate/20260715072549_create_instagram_connect_conversations.rb

@@ -1,6 +1,6 @@
 class CreateInstagramConnectConversations < ActiveRecord::Migration[7.1]
   def change
-    create_table :instagram_connect_conversations do |t|
+    create_table :instagram_connect_conversations, if_not_exists: true do |t|
       t.bigint :account_id, null: false
       t.string :igsid, null: false
       t.string :username
@@ -11,6 +11,6 @@ class CreateInstagramConnectConversations < ActiveRecord::Migration[7.1]
       t.integer :unread_count, default: 0, null: false
       t.timestamps
     end
-    add_index :instagram_connect_conversations, [ :account_id, :igsid ], unique: true
+    add_index :instagram_connect_conversations, [ :account_id, :igsid ], unique: true, if_not_exists: true
   end
 end

data/db/migrate/20260715072550_create_instagram_connect_messages.rb

@@ -1,6 +1,6 @@
 class CreateInstagramConnectMessages < ActiveRecord::Migration[7.1]
   def change
-    create_table :instagram_connect_messages do |t|
+    create_table :instagram_connect_messages, if_not_exists: true do |t|
       t.bigint :conversation_id, null: false
       t.string :direction, null: false
       t.string :status, null: false
@@ -19,7 +19,7 @@ class CreateInstagramConnectMessages < ActiveRecord::Migration[7.1]
       t.string :failure_reason
       t.timestamps
     end
-    add_index :instagram_connect_messages, :conversation_id
-    add_index :instagram_connect_messages, :ig_message_id, unique: true
+    add_index :instagram_connect_messages, :conversation_id, if_not_exists: true
+    add_index :instagram_connect_messages, :ig_message_id, unique: true, if_not_exists: true
   end
 end

data/db/migrate/20260715072551_create_instagram_connect_inbound_messages.rb

@@ -1,11 +1,11 @@
 class CreateInstagramConnectInboundMessages < ActiveRecord::Migration[7.1]
   def change
-    create_table :instagram_connect_inbound_messages do |t|
+    create_table :instagram_connect_inbound_messages, if_not_exists: true do |t|
       t.string :ig_message_id, null: false
       t.bigint :account_id
       t.datetime :processed_at
       t.timestamps
     end
-    add_index :instagram_connect_inbound_messages, :ig_message_id, unique: true
+    add_index :instagram_connect_inbound_messages, :ig_message_id, unique: true, if_not_exists: true
   end
 end

data/db/migrate/20260715072552_create_instagram_connect_comments.rb

@@ -1,6 +1,6 @@
 class CreateInstagramConnectComments < ActiveRecord::Migration[7.1]
   def change
-    create_table :instagram_connect_comments do |t|
+    create_table :instagram_connect_comments, if_not_exists: true do |t|
       t.bigint :account_id, null: false
       t.string :media_id
       t.string :comment_id, null: false
@@ -11,7 +11,7 @@ class CreateInstagramConnectComments < ActiveRecord::Migration[7.1]
       t.datetime :replied_at
       t.timestamps
     end
-    add_index :instagram_connect_comments, :comment_id, unique: true
-    add_index :instagram_connect_comments, :account_id
+    add_index :instagram_connect_comments, :comment_id, unique: true, if_not_exists: true
+    add_index :instagram_connect_comments, :account_id, if_not_exists: true
   end
 end

data/db/migrate/20260725194732_create_instagram_connect_webhook_events.rb

@@ -0,0 +1,52 @@
+class CreateInstagramConnectWebhookEvents < ActiveRecord::Migration[7.1]
+  # Every webhook event Meta delivers, stored verbatim before anything tries to
+  # interpret it.
+  #
+  # Meta does not store `mentions` or `story_insights` notifications and never
+  # re-delivers any event, so a parse bug against a live payload is permanent
+  # data loss. With this table it is a re-runnable row instead. It also lets an
+  # operator subscribe a field at Meta before its handler exists — the events
+  # bank as "unhandled" and ReplayEventsJob walks them once the handler ships.
+  def change
+    create_table :instagram_connect_webhook_events, if_not_exists: true do |t|
+      # Nullable: an entry whose id matches no connected account is recorded
+      # rather than dropped. That is how you discover a second Page was
+      # connected to the app, instead of losing a week of DMs to a counter.
+      t.bigint :account_id
+      t.string :object
+      t.string :field, null: false
+      t.string :event_type, null: false
+      t.string :dedupe_key, null: false
+      t.string :entry_id
+      t.datetime :occurred_at
+      t.datetime :received_at, null: false
+      t.datetime :processed_at
+      t.string :status, null: false, default: "pending"
+      t.string :handler
+      t.string :error_class
+      t.text :error_message
+      t.integer :attempts, null: false, default: 0
+      t.string :subject_type
+      t.bigint :subject_id
+      t.column :payload, json_type, null: false
+      t.timestamps
+    end
+
+    add_index :instagram_connect_webhook_events, [ :field, :dedupe_key ],
+              unique: true, if_not_exists: true
+    add_index :instagram_connect_webhook_events, [ :account_id, :field, :occurred_at ],
+              name: "index_instagram_connect_webhook_events_on_account_field_time",
+              if_not_exists: true
+    add_index :instagram_connect_webhook_events, [ :status, :created_at ], if_not_exists: true
+    add_index :instagram_connect_webhook_events, [ :subject_type, :subject_id ], if_not_exists: true
+  end
+
+  private
+
+  # The gem ships into whichever database the host runs. jsonb is the right
+  # column on Postgres and does not exist on SQLite, so pick per adapter rather
+  # than forcing every adopter onto one.
+  def json_type
+    connection.adapter_name.match?(/postg/i) ? :jsonb : :json
+  end
+end