postproxy-sdk 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0aea2892ef3d3256dfd1cc9ce790da283df1d6edb83a2cfcaa76c0aa8a8194ae
-  data.tar.gz: a9f008666d47832963cc7119d0db1b53d53c7ddd3dc690fa13acebc05c72f5f6
+  metadata.gz: 1d2f9ae8cbbc2ca3cd324b5dc522226c9d7a77cd93430abb309b31efc210a293
+  data.tar.gz: 26c58e5f9b7ea1af4eccb3935ef8c71bf202bf5bff93898d0b30a5450114bb1a
 SHA512:
-  metadata.gz: c9f6cf9ec0d398081c84c21c41824bd590fa9d57b7e8eea423512bcc899b82d3df93c4532edf307e2f949a0d72217e6677743b36434a4384e9b9d801030b4aa4
-  data.tar.gz: 325923dc017d840f212edac1941f2f2aa8d8821594f2418e40dee1e1b56a8f103627ab1f8cb9adb07f576afcc8fe5a6b431fcc408a50c4ac6887948bf80426d6
+  metadata.gz: 906800719560c2e37351c958fa72449d1411b351c1cad4deb0d312e9b6fcaa3af3be3dcb504eeef045a3d24737815afb4e7f772edae4687e102e2f9d4bd605cc
+  data.tar.gz: b6ee51b608b91a9d31ed2891b7bba87df996006be1795504f540e275dd54c8ff3b7ef7e5f1994a7aa495a02f67ec8f3921e9017baadb3e1e8d3c5550d6959b06

data/README.md

@@ -260,6 +260,26 @@ PostProxy::WebhookSignature.verify(
 )
 ```
 
+### Event types and typed payloads
+
+Subscribe to any of these events (or pass `["*"]` for all):
+
+`post.processed`, `post.imported`, `platform_post.published`, `platform_post.failed`, `platform_post.failed_waiting_for_retry`, `platform_post.insights`, `profile.connected`, `profile.disconnected`, `profile.stats`, `media.failed`, `comment.created`.
+
+`PostProxy::WebhookEvents.parse` validates the envelope and returns a typed `Event` — `event.data` is the right model for the event:
+
+```ruby
+event = PostProxy::WebhookEvents.parse(request.body.read)
+case event.type
+when "profile.stats"
+  puts "#{event.data.profile_id}: #{event.data.stats}"
+when "platform_post.published"
+  puts "Published: #{event.data.platform_id}"
+when "comment.created"
+  puts "#{event.data.author_username}: #{event.data.body}"
+end
+```
+
 ## Comments
 
 ```ruby
@@ -311,6 +331,19 @@ placements = client.profiles.placements("prof-id").data
 
 # Delete a profile
 client.profiles.delete("prof-id")
+
+# Profile stats timeseries — placement_id required for facebook, linkedin, telegram
+stats = client.profiles.get_profile_stats("prof_li_001",
+  placement_id: "108520199",
+  from: "2026-04-01T00:00:00Z"
+)
+stats.data.records.each do |r|
+  puts "#{r.recorded_at}: #{r.stats[:followerCount]}"
+end
+
+# Bluesky — no placements
+bsky = client.profiles.get_profile_stats("prof_bsky_001")
+puts bsky.data.records.last.stats[:followersCount]
 ```
 
 ## Profile Groups
@@ -335,6 +368,28 @@ connection = client.profile_groups.initialize_connection(
   redirect_url: "https://myapp.com/callback"
 )
 # Redirect user to connection.url
+
+# BlueSky — app password (synchronous, no OAuth)
+bsky = client.profile_groups.connect_bluesky("pg-id",
+  identifier: "yourname.bsky.social",
+  app_password: "xxxx-xxxx-xxxx-xxxx"
+)
+puts bsky.profile.id
+
+# Telegram — bring-your-own-bot. Channels populate asynchronously; poll
+# placements until non-empty.
+tg = client.profile_groups.connect_telegram("pg-id",
+  bot_token: "123456789:ABCdef-GhIJklMnOpQrStUvWxYz"
+)
+puts tg.next_step
+
+placements = []
+loop do
+  placements = client.profiles.placements(tg.profile.id).data
+  break unless placements.empty?
+  sleep 3
+end
+puts "Channels: #{placements.map { |p| [p.id, p.name] }}"
 ```
 
 ## Platform Parameters
@@ -364,7 +419,13 @@ platforms = PostProxy::PlatformParams.new(
     board_id: "board-123"
   ),
   threads: PostProxy::ThreadsParams.new(format: "post"),
-  twitter: PostProxy::TwitterParams.new(format: "post")
+  twitter: PostProxy::TwitterParams.new(format: "post"),
+  bluesky: PostProxy::BlueskyParams.new(format: "post"),
+  telegram: PostProxy::TelegramParams.new(
+    chat_id: "-1001234567890",
+    parse_mode: "HTML",
+    disable_link_preview: true
+  )
 )
 
 post = client.posts.create(
@@ -374,6 +435,8 @@ post = client.posts.create(
 )
 ```
 
+Supported platforms: `facebook`, `instagram`, `tiktok`, `linkedin`, `youtube`, `twitter`, `threads`, `pinterest`, `bluesky`, `telegram`. Telegram requires a `chat_id` per post — list channels with `client.profiles.placements(profile_id)`.
+
 ## Error Handling
 
 ```ruby

data/lib/postproxy/client.rb

@@ -99,11 +99,16 @@ module PostProxy
 
     private
 
+    def user_agent
+      @user_agent ||= "postproxy-ruby/#{PostProxy::VERSION} (ruby/#{RUBY_VERSION})"
+    end
+
     def json_connection
       @faraday_client || Faraday.new(url: @base_url) do |f|
         f.request :url_encoded
         f.headers["Authorization"] = "Bearer #{@api_key}"
         f.headers["Content-Type"] = "application/json"
+        f.headers["User-Agent"] = user_agent
         f.adapter Faraday.default_adapter
       end
     end
@@ -112,6 +117,7 @@ module PostProxy
       @faraday_client || Faraday.new(url: @base_url) do |f|
         f.request :multipart
         f.headers["Authorization"] = "Bearer #{@api_key}"
+        f.headers["User-Agent"] = user_agent
         f.adapter Faraday.default_adapter
       end
     end

data/lib/postproxy/constants.rb

@@ -2,7 +2,7 @@ module PostProxy
   DEFAULT_BASE_URL = "https://api.postproxy.dev"
 
   PLATFORMS = %w[
-    facebook instagram tiktok linkedin youtube twitter threads pinterest
+    facebook instagram tiktok linkedin youtube twitter threads pinterest bluesky telegram
   ].freeze
 
   PROFILE_STATUSES = %w[active expired inactive].freeze
@@ -21,10 +21,28 @@ module PostProxy
   PINTEREST_FORMATS = %w[pin].freeze
   THREADS_FORMATS = %w[post].freeze
   TWITTER_FORMATS = %w[post].freeze
+  BLUESKY_FORMATS = %w[post].freeze
+  TELEGRAM_FORMATS = %w[post].freeze
 
   TIKTOK_PRIVACIES = %w[
     PUBLIC_TO_EVERYONE MUTUAL_FOLLOW_FRIENDS FOLLOWER_OF_CREATOR SELF_ONLY
   ].freeze
 
   YOUTUBE_PRIVACIES = %w[public unlisted private].freeze
+
+  TELEGRAM_PARSE_MODES = %w[HTML MarkdownV2].freeze
+
+  WEBHOOK_EVENT_TYPES = %w[
+    post.processed
+    post.imported
+    platform_post.published
+    platform_post.failed
+    platform_post.failed_waiting_for_retry
+    platform_post.insights
+    profile.connected
+    profile.disconnected
+    profile.stats
+    media.failed
+    comment.created
+  ].freeze
 end

data/lib/postproxy/resources/profile_groups.rb

@@ -26,11 +26,28 @@ module PostProxy
         DeleteResponse.new(**result)
       end
 
-      def initialize_connection(id, platform:, redirect_url:)
+      # OAuth flow. BlueSky and Telegram use their dedicated helpers below.
+      def initialize_connection(id, platform:, redirect_url: nil)
+        body = { platform: platform }
+        body[:redirect_url] = redirect_url if redirect_url
+        result = @client.request(:post, "/profile_groups/#{id}/initialize_connection", json: body)
+        ConnectionResponse.new(**result)
+      end
+
+      def connect_bluesky(id, identifier:, app_password:)
         result = @client.request(:post, "/profile_groups/#{id}/initialize_connection",
-          json: { platform: platform, redirect_url: redirect_url }
+          json: { platform: "bluesky", identifier: identifier, app_password: app_password }
         )
-        ConnectionResponse.new(**result)
+        BlueskyConnectionResponse.new(**result)
+      end
+
+      # After this call, poll `client.profiles.placements(profile.id)` until non-empty —
+      # the bot must be added as administrator to a channel in Telegram first.
+      def connect_telegram(id, bot_token:)
+        result = @client.request(:post, "/profile_groups/#{id}/initialize_connection",
+          json: { platform: "telegram", bot_token: bot_token }
+        )
+        TelegramConnectionResponse.new(**result)
       end
     end
   end

data/lib/postproxy/resources/profiles.rb

@@ -22,6 +22,20 @@ module PostProxy
         ListResponse.new(data: items)
       end
 
+      # `placement_id` is required for facebook, linkedin, and telegram profiles.
+      def get_profile_stats(id, placement_id: nil, from: nil, to: nil, profile_group_id: nil)
+        params = {}
+        params[:placement_id] = placement_id if placement_id
+        params[:from] = from if from
+        params[:to] = to if to
+
+        result = @client.request(:get, "/profiles/#{id}/stats",
+          params: params.empty? ? nil : params,
+          profile_group_id: profile_group_id
+        )
+        ProfileStatsResponse.new(data: result[:data])
+      end
+
       def delete(id, profile_group_id: nil)
         result = @client.request(:delete, "/profiles/#{id}", profile_group_id: profile_group_id)
         SuccessResponse.new(**result)

data/lib/postproxy/types.rb

@@ -350,10 +350,60 @@ module PostProxy
     attr_accessor :success
   end
 
+  # OAuth-style connection response (facebook, instagram, twitter, etc.).
   class ConnectionResponse < Model
     attr_accessor :url, :success
   end
 
+  # Alias for clarity at call sites; same shape as ConnectionResponse.
+  OAuthConnectionResponse = ConnectionResponse
+
+  class SyncProfile < Model
+    attr_accessor :id, :network, :name, :external_username
+  end
+
+  class BlueskyConnectionResponse < Model
+    attr_accessor :success, :profile
+
+    def initialize(**attrs)
+      @profile = nil
+      super
+      @profile = SyncProfile.new(**@profile.transform_keys(&:to_sym)) if @profile.is_a?(Hash)
+    end
+  end
+
+  class TelegramConnectionResponse < Model
+    attr_accessor :success, :profile, :next_step
+
+    def initialize(**attrs)
+      @profile = nil
+      @next_step = nil
+      super
+      @profile = SyncProfile.new(**@profile.transform_keys(&:to_sym)) if @profile.is_a?(Hash)
+    end
+  end
+
+  class ProfileStats < Model
+    attr_accessor :profile_id, :platform, :placement_id, :records
+
+    def initialize(**attrs)
+      @placement_id = nil
+      @records = []
+      super
+      @records = (@records || []).map do |r|
+        r.is_a?(StatsRecord) ? r : StatsRecord.new(**r.transform_keys(&:to_sym))
+      end
+    end
+  end
+
+  class ProfileStatsResponse
+    attr_reader :data
+
+    def initialize(data:)
+      @data = data.is_a?(ProfileStats) ? data : ProfileStats.new(**data.transform_keys(&:to_sym))
+    end
+  end
+
   # Platform-specific parameter structs
 
   class FacebookParams < Model
@@ -392,13 +442,21 @@ module PostProxy
     attr_accessor :format
   end
 
+  class BlueskyParams < Model
+    attr_accessor :format
+  end
+
+  class TelegramParams < Model
+    attr_accessor :format, :chat_id, :parse_mode, :disable_link_preview, :disable_notification
+  end
+
   class PlatformParams < Model
     attr_accessor :facebook, :instagram, :tiktok, :linkedin, :youtube,
-                  :pinterest, :threads, :twitter
+                  :pinterest, :threads, :twitter, :bluesky, :telegram
 
     def to_h
       result = {}
-      %i[facebook instagram tiktok linkedin youtube pinterest threads twitter].each do |platform|
+      %i[facebook instagram tiktok linkedin youtube pinterest threads twitter bluesky telegram].each do |platform|
         value = send(platform)
         next if value.nil?
 

data/lib/postproxy/version.rb

@@ -1,3 +1,3 @@
 module PostProxy
-  VERSION = "1.7.0"
+  VERSION = "1.8.0"
 end

data/lib/postproxy/webhook_events.rb

@@ -0,0 +1,113 @@
+require "json"
+
+module PostProxy
+  class WebhookParseError < StandardError; end
+
+  module WebhookEvents
+    class Event < Model
+      attr_accessor :id, :type, :created_at, :data
+    end
+
+    class PostProcessedPlatform < Model
+      attr_accessor :id, :platform, :name
+    end
+
+    class PostProcessedData < Model
+      attr_accessor :id, :body, :status, :scheduled_at, :created_at, :platforms
+
+      def initialize(**attrs)
+        @platforms = []
+        super
+        @platforms = (@platforms || []).map do |p|
+          p.is_a?(PostProcessedPlatform) ? p : PostProcessedPlatform.new(**p.transform_keys(&:to_sym))
+        end
+      end
+    end
+
+    class ImportedProfile < Model
+      attr_accessor :id, :name, :platform
+    end
+
+    class PostImportedData < Model
+      attr_accessor :id, :body, :source, :posted_at, :created_at,
+                    :platform, :profile, :platform_post_id, :public_id
+
+      def initialize(**attrs)
+        @profile = nil
+        super
+        @profile = ImportedProfile.new(**@profile.transform_keys(&:to_sym)) if @profile.is_a?(Hash)
+      end
+    end
+
+    class PlatformPostData < Model
+      attr_accessor :id, :post_id, :platform, :profile_id, :profile_name,
+                    :status, :error, :error_details, :platform_id, :insights
+
+      def initialize(**attrs)
+        @error_details = nil
+        @insights = nil
+        super
+        @error_details = ErrorDetails.new(**@error_details.transform_keys(&:to_sym)) if @error_details.is_a?(Hash)
+      end
+    end
+
+    class ProfileEventData < Model
+      attr_accessor :id, :name, :platform, :profile_group_id, :status, :uid, :username
+    end
+
+    class ProfileStatsData < Model
+      attr_accessor :profile_id, :platform, :placement_id, :stats, :recorded_at
+    end
+
+    class MediaFailedData < Model
+      attr_accessor :id, :post_id, :content_type, :status, :error_message
+    end
+
+    class CommentCreatedData < Model
+      attr_accessor :id, :post_id, :platform_post_id, :platform, :external_id,
+                    :parent_external_id, :body, :status, :author_external_id,
+                    :author_name, :author_username, :author_avatar_url,
+                    :like_count, :reply_count, :is_hidden, :permalink,
+                    :platform_data, :posted_at, :created_at
+    end
+
+    DATA_CLASSES = {
+      "post.processed" => PostProcessedData,
+      "post.imported" => PostImportedData,
+      "platform_post.published" => PlatformPostData,
+      "platform_post.failed" => PlatformPostData,
+      "platform_post.failed_waiting_for_retry" => PlatformPostData,
+      "platform_post.insights" => PlatformPostData,
+      "profile.connected" => ProfileEventData,
+      "profile.disconnected" => ProfileEventData,
+      "profile.stats" => ProfileStatsData,
+      "media.failed" => MediaFailedData,
+      "comment.created" => CommentCreatedData
+    }.freeze
+
+    # Parse a webhook body and return a typed Event. `data` is parsed into the
+    # appropriate model based on `type`. Raises WebhookParseError on bad input.
+    def self.parse(body)
+      parsed =
+        case body
+        when String then JSON.parse(body, symbolize_names: true)
+        when Hash then body.transform_keys(&:to_sym)
+        else raise WebhookParseError, "Webhook body must be a String or Hash"
+        end
+    rescue JSON::ParserError => e
+      raise WebhookParseError, "Invalid JSON: #{e.message}"
+    else
+      type = parsed[:type].to_s
+      raise WebhookParseError, "Unknown webhook event type: #{type.inspect}" unless DATA_CLASSES.key?(type)
+
+      data_class = DATA_CLASSES[type]
+      data_hash = (parsed[:data] || {}).transform_keys(&:to_sym)
+      Event.new(
+        id: parsed[:id],
+        type: type,
+        created_at: parsed[:created_at],
+        data: data_class.new(**data_hash)
+      )
+    end
+  end
+end

data/lib/postproxy.rb

@@ -4,6 +4,7 @@ require_relative "postproxy/errors"
 require_relative "postproxy/types"
 require_relative "postproxy/client"
 require_relative "postproxy/webhook_signature"
+require_relative "postproxy/webhook_events"
 
 module PostProxy
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: postproxy-sdk
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
 - PostProxy
@@ -86,6 +86,7 @@ files:
 - lib/postproxy/resources/webhooks.rb
 - lib/postproxy/types.rb
 - lib/postproxy/version.rb
+- lib/postproxy/webhook_events.rb
 - lib/postproxy/webhook_signature.rb
 homepage: https://postproxy.dev
 licenses: