add an importer from quotes and pins (bookmarks)

app/importers/posts_importer.rb

···
+require 'time'
+
+require_relative '../at_uri'
+require_relative 'base_importer'
+
+class PostsImporter < BaseImporter
+  def import_items
+    params = { repo: @did, collection: 'app.bsky.feed.post', limit: 100 }
+    params[:cursor] = @import.cursor if @import.cursor
+
+    loop do
+      response = @minisky.get_request('com.atproto.repo.listRecords', params)
+
+      records = response['records']
+      cursor = response['cursor']
+
+      @imported_count += records.length
+      @report&.update(importers: { importer_name => { :imported_items => @imported_count }})
+      @report&.update(importers: { importer_name => { :oldest_date => Time.parse(records.last['value']['createdAt']) }}) unless records.empty?
+
+      records.each do |record|
+        begin
+          if record['value']['embed'] && record['value']['embed']['record']
+            save_quote(record)
+          end
+
+          if record['value']['reply'] && record['value']['text'].include?('📌')
+            save_pin(record)
+          end
+        rescue StandardError => e
+          puts "Error in LikesImporter: #{record['uri']}: #{e}"
+        end
+      end
+
+      params[:cursor] = cursor
+      @import.update!(cursor: cursor)
+
+      break if !cursor
+      break if @time_limit && records.any? { |x| Time.parse(x['value']['createdAt']) < @time_limit }
+    end
+  end
+
+  def save_quote(record)
+    post_rkey = AT_URI(record['uri']).rkey
+    return if @user.quotes.where(rkey: post_rkey).exists?
+
+    post_time = Time.parse(record['value']['createdAt'])
+
+    quoted_post_uri = case record['value']['embed']['$type']
+    when 'app.bsky.embed.record'
+      record['value']['embed']['record']['uri']
+    when 'app.bsky.embed.recordWithMedia'
+      record['value']['embed']['record']['record']['uri']
+    else
+      return
+    end
+
+    create_item_for_post(quoted_post_uri) do |args|
+      @user.quotes.create!(args.merge(rkey: post_rkey, time: post_time, quote_text: record['value']['text']))
+    end
+  end
+
+  def save_pin(record)
+    post_rkey = AT_URI(record['uri']).rkey
+    return if @user.pins.where(rkey: post_rkey).exists?
+
+    post_time = Time.parse(record['value']['createdAt'])
+    parent_post_uri = record['value']['reply']['parent']['uri']
+
+    create_item_for_post(parent_post_uri) do |args|
+      @user.pins.create!(args.merge(rkey: post_rkey, time: post_time, pin_text: record['value']['text']))
+    end
+  end
+end

app/models/import.rb

···
 class Import < ActiveRecord::Base
   belongs_to :user
 
-  validates_inclusion_of :collection, in: %w(likes reposts)
+  validates_inclusion_of :collection, in: %w(likes reposts posts)
   validates_uniqueness_of :collection, scope: :user_id
 end

app/models/pin.rb

···
+require 'active_record'
+
+require_relative 'post'
+require_relative 'searchable'
+require_relative 'user'
+
+class Pin < ActiveRecord::Base
+  include Searchable
+
+  validates_presence_of :time, :rkey
+  validates_length_of :rkey, maximum: 13
+  validates :pin_text, length: { minimum: 0, maximum: 1000, allow_nil: false }
+
+  validates_presence_of :post_uri, if: -> { post_id.nil? }
+
+  belongs_to :user, foreign_key: 'actor_id'
+  belongs_to :post, optional: true
+end

app/models/quote.rb

···
+require 'active_record'
+
+require_relative 'post'
+require_relative 'searchable'
+require_relative 'user'
+
+class Quote < ActiveRecord::Base
+  include Searchable
+
+  validates_presence_of :time, :rkey
+  validates_length_of :rkey, maximum: 13
+  validates :quote_text, length: { minimum: 0, maximum: 1000, allow_nil: false }
+
+  validates_presence_of :post_uri, if: -> { post_id.nil? }
+
+  belongs_to :user, foreign_key: 'actor_id'
+  belongs_to :post, optional: true
+end

app/models/user.rb

···
 
 require_relative 'import'
 require_relative 'like'
+require_relative 'quote'
+require_relative 'pin'
 require_relative 'post'
 require_relative 'repost'
 
···
   has_many :posts
   has_many :likes, foreign_key: 'actor_id'
   has_many :reposts, foreign_key: 'actor_id'
+  has_many :quotes, foreign_key: 'actor_id'
+  has_many :pins, foreign_key: 'actor_id'
   has_many :imports
 end

app/server.rb

···
 
     collection = case params[:collection]
     when 'likes'   then user.likes
+    when 'pins'    then user.pins
+    when 'quotes'  then user.quotes
     when 'reposts' then user.reposts
     else return json_error('InvalidParameter', 'Invalid search collection')
     end
···
       .after_cursor(params[:cursor])
       .limit(PAGE_LIMIT)
 
-    post_uris = items.map(&:post).map(&:at_uri)
+    post_uris = case params[:collection]
+    when 'quotes'
+      items.map { |x| "at://#{user.did}/app.bsky.feed.post/#{x.rkey}" }
+    else
+      items.map(&:post).map(&:at_uri)
+    end
 
     json_response(posts: post_uris, cursor: items.last&.cursor)
   end

db/migrate/20250906233017_add_quotes_and_pins.rb

···
+class AddQuotesAndPins < ActiveRecord::Migration[7.2]
+  def change
+    create_table :quotes do |t|
+      t.integer "actor_id", null: false
+      t.string "rkey", limit: 13, null: false
+      t.datetime "time", null: false
+      t.text "quote_text", null: false
+      t.bigint "post_id"
+      t.string "post_uri"
+    end
+
+    add_index :quotes, [:actor_id, :time, :id], order: { time: :desc, id: :desc }
+    add_index :quotes, [:actor_id, :rkey], unique: true
+
+    create_table :pins do |t|
+      t.integer "actor_id", null: false
+      t.string "rkey", limit: 13, null: false
+      t.datetime "time", null: false
+      t.text "pin_text", null: false
+      t.bigint "post_id"
+      t.string "post_uri"
+    end
+
+    add_index :pins, [:actor_id, :time, :id], order: { time: :desc, id: :desc }
+    add_index :pins, [:actor_id, :rkey], unique: true
+  end
+end

db/schema.rb

···
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[7.2].define(version: 2025_09_06_005748) do
+ActiveRecord::Schema[7.2].define(version: 2025_09_06_233017) do
   # These are extensions that must be enabled in order to support this database
   enable_extension "plpgsql"
 
···
     t.index ["actor_id", "time", "id"], name: "index_likes_on_actor_id_and_time_and_id", order: { time: :desc, id: :desc }
   end
 
+  create_table "pins", force: :cascade do |t|
+    t.integer "actor_id", null: false
+    t.string "rkey", limit: 13, null: false
+    t.datetime "time", null: false
+    t.text "pin_text", null: false
+    t.bigint "post_id"
+    t.string "post_uri"
+    t.index ["actor_id", "rkey"], name: "index_pins_on_actor_id_and_rkey", unique: true
+    t.index ["actor_id", "time", "id"], name: "index_pins_on_actor_id_and_time_and_id", order: { time: :desc, id: :desc }
+  end
+
   create_table "posts", force: :cascade do |t|
     t.integer "user_id", null: false
     t.string "rkey", limit: 13, null: false
···
     t.text "data", null: false
     t.index ["user_id", "rkey"], name: "index_posts_on_user_id_and_rkey", unique: true
     t.index ["user_id", "time", "id"], name: "index_posts_on_user_id_and_time_and_id", order: { time: :desc, id: :desc }
+  end
+
+  create_table "quotes", force: :cascade do |t|
+    t.integer "actor_id", null: false
+    t.string "rkey", limit: 13, null: false
+    t.datetime "time", null: false
+    t.text "quote_text", null: false
+    t.bigint "post_id"
+    t.string "post_uri"
+    t.index ["actor_id", "rkey"], name: "index_quotes_on_actor_id_and_rkey", unique: true
+    t.index ["actor_id", "time", "id"], name: "index_quotes_on_actor_id_and_time_and_id", order: { time: :desc, id: :desc }
   end
 
   create_table "reposts", force: :cascade do |t|

lib/tasks/import.rake

···
 require_relative '../../app/importers/likes_importer'
+require_relative '../../app/importers/posts_importer'
 require_relative '../../app/importers/reposts_importer'
+
 require_relative '../../app/import_report'
 require_relative '../../app/item_queue'
 require_relative '../../app/post_downloader'
···
   when 'reposts'
     queue = ItemQueue.new(user.reposts.where(post: nil).to_a)
     importer = RepostsImporter.new(ENV['USER'])
+  when 'posts'
+    queue = ItemQueue.new(user.quotes.where(post: nil).to_a + user.pins.where(post: nil).to_a)
+    importer = PostsImporter.new(ENV['USER'])
   when nil
     raise "Required COLLECTION parameter missing"
   else