tiktok-open-sdk 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5baf485e6b6be4c1d0541f8d8d3ff76232bba37253fe7e6d89a6a9359328dc04
-  data.tar.gz: 398eb5072ac7be7fd647679f408ecfa94fce22ff44c4993bf1891637d7cc6150
+  metadata.gz: ea350ded46bc468a3b86a72f539c12a36ecc960b1e2476ac7e59c2c52424d8f1
+  data.tar.gz: 07fa578800d4d03d9431c39b043008d2185ed62ed2f93c8c20feea8bb331736d
 SHA512:
-  metadata.gz: e3ade7fbfaaea010568b79c807b52d65fa4398f486889387ab07a01db54163021a410d77a76552f865599b32db2d40cd89c19df11964ebc83a19022d163887d3
-  data.tar.gz: b512cb261c7b577a74523b501a25daddce2e1196f90ebc9351cf1472516f33fb1634bd1b501bd04649cdb10c44c9c97513fd0a0474de533bba59f8e1eb15c530
+  metadata.gz: 61e3742ea46ddeb02a8a168d3485c7ecc7632698c6c533364e392b67058f6a5d7e325e0e546eebe9eee915070e309981dc8707aca7ff67097dfadd74610977d0
+  data.tar.gz: f19aa49f93036f0b02f0d5613d76b7bd86e7a00457a3642569c3f266ac895720a4106e7df27fec6f215581ccfd6fcedb71ac68638c83fdddcfc0dca8b56d5052

data/.rubocop.yml

@@ -7,6 +7,9 @@ AllCops:
   NewCops: enable
   SuggestExtensions: false
 
+Naming/VariableNumber:
+  EnforcedStyle: snake_case
+
 Metrics/MethodLength:
   Max: 15
 
@@ -27,7 +30,7 @@ Style/ModuleFunction:
   Enabled: false
 
 RSpec/NestedGroups:
-  Max: 4
+  Max: 5
 
 RSpec/MultipleExpectations:
   Max: 5

data/CHANGELOG.md

@@ -4,7 +4,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [Unreleased]
+## [0.5.0] - 2026-02-14
+### Added
+- **Post API: video_init** - Initialize a video publish to obtain an upload URL (file upload) or to start a pull-from-URL flow. Accepts `access_token` and `params` (post_info, source_info). Optional config: `video_init_url`.
+
+## [0.4.0] - 2025-10-06
+### Added
+- **OmniAuth Strategy** - Ready-to-use OmniAuth strategy for TikTok Open Platform integration in Rails applications
+  - Supports multiple TikTok OAuth scopes (user.info.basic, user.info.profile, user.info.stats)
+  - Automatic token handling and user info retrieval
+  - Rails/Devise integration examples and callbacks
+- **Post API** - New module for interacting with TikTok's Post API endpoints
+  - Creator info query functionality for video publishing workflows
+  - Support for querying creator settings and capabilities
 
 ## [0.3.0] - 2025-09-20
 ### Added

data/README.md

@@ -1,6 +1,6 @@
 # TikTok Open SDK
 
-[![Gem Version](https://img.shields.io/badge/gem-v0.3.0-blue.svg)](https://rubygems.org/gems/tiktok-open-sdk)
+[![Gem Version](https://img.shields.io/badge/gem-v0.5.0-blue.svg)](https://rubygems.org/gems/tiktok-open-sdk)
 [![Ruby Version](https://img.shields.io/badge/ruby-%3E%3D%203.0.0-red.svg)](https://www.ruby-lang.org/en/downloads/)
 [![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE.txt)
 [![CI](https://github.com/pochkuntaras/tiktok-open-sdk/actions/workflows/main.yml/badge.svg)](https://github.com/pochkuntaras/tiktok-open-sdk/actions/workflows/main.yml)
@@ -10,9 +10,11 @@ A comprehensive Ruby SDK for integrating with TikTok Open API. This gem provides
 ## Features
 
 - **OAuth 2.0 Authentication** – Seamless OAuth flow for secure integration
+- **OmniAuth Strategy** – Ready-to-use OmniAuth strategy for Rails applications
 - **Client Authentication** – Server-to-server authentication with client credentials
 - **Token Management** – Easy access token exchange and refresh
 - **User API** – Convenient methods to access user information
+- **Post API** – Methods for querying creator information and video publishing
 - **HTTP Client** – Built-in client for interacting with TikTok APIs
 
 ## Installation
@@ -56,6 +58,11 @@ Tiktok::Open::Sdk.configure do |config|
   config.user_auth.token_url        = 'https://open.tiktokapis.com/v2/oauth/token/'
   config.user_auth.revoke_token_url = 'https://open.tiktokapis.com/v2/oauth/revoke/'
   config.user_info_url              = 'https://open.tiktokapis.com/v2/user/info/'
+  config.creator_info_query_url     = 'https://open.tiktokapis.com/v2/post/publish/creator_info/query/'
+  config.video_init_url             = 'https://open.tiktokapis.com/v2/post/publish/video/init/'
+
+  # Optional: Enable OmniAuth strategy auto-loading
+  config.load_omniauth = true
 end
 ```
 
@@ -158,13 +165,71 @@ end
 
 **Note:** Client tokens are used for server-to-server authentication and have different scopes and permissions than user tokens.
 
+### Using the Post API
+
+The SDK provides convenient methods for interacting with TikTok's Post API:
+
+#### Creator Info Query
+
+Query creator information for video publishing:
+
+```ruby
+# Get creator information
+response = Tiktok::Open::Sdk.post.creator_info_query(access_token: access_token)
+
+if response[:success]
+  creator_data = response[:response][:data]
+
+  puts "Creator Avatar: #{creator_data[:creator_avatar_url]}"
+  puts "Creator Nickname: #{creator_data[:creator_nickname]}"
+  puts "Max Video Duration: #{creator_data[:max_video_post_duration_sec]} seconds"
+  puts "Privacy Options: #{creator_data[:privacy_level_options]}"
+else
+  puts "Error: #{response[:response][:error][:message]}"
+end
+```
+
+#### Video Init
+
+Initialize a video publish to obtain an upload URL (for file upload) or to start a pull-from-URL flow:
+
+```ruby
+params = {
+  post_info: {
+    title:                    'My video #tiktok',
+    privacy_level:            'SELF_ONLY',
+    disable_duet:             false,
+    disable_comment:          false,
+    disable_stitch:           false,
+    video_cover_timestamp_ms: 1000
+  },
+  source_info: {
+    source:            'FILE_UPLOAD',
+    video_type:        'video/mp4',
+    video_size:        7_340_032,
+    chunk_size:        7_340_032,
+    total_chunk_count: 1
+  }
+}
+
+response = Tiktok::Open::Sdk.post.video_init(access_token: access_token, params: params)
+
+if response[:success]
+  publish_id = response[:response][:data][:publish_id]
+  upload_url = response[:response][:data][:upload_url]
+  # Use upload_url to upload video chunks (FILE_UPLOAD) or proceed with PULL_FROM_URL flow
+else
+  puts "Error: #{response[:response][:error][:message]}"
+end
+```
+
 ### Using the User API
 
 The SDK provides a convenient way to access user information:
 
 ```ruby
 # Get user information
-response = Tiktok::Open::Sdk::OpenApi::User.get_user_info(
+response = Tiktok::Open::Sdk.user.get_user_info(
   access_token: access_token,
   fields: %w[open_id union_id avatar_url display_name]
 )
@@ -187,6 +252,73 @@ Available user fields include:
 - `username` - User's username
 - And more (see documentation for full list)
 
+### Using OmniAuth Strategy
+
+The SDK provides a ready-to-use OmniAuth strategy for Rails applications:
+
+#### Rails Setup
+
+Add the OmniAuth strategy to your Rails application:
+
+```ruby
+# config/initializers/devise.rb
+Devise.setup do |config|
+  config.omniauth(
+    :tiktok_open_sdk,
+    Rails.application.credentials.dig(:tiktok, :client_key),
+    Rails.application.credentials.dig(:tiktok, :client_secret),
+    scope:         'user.info.basic,user.info.profile,user.info.stats',
+  )
+end
+```
+
+Or use the SDK configuration:
+
+```ruby
+# config/initializers/tiktok_sdk.rb
+Tiktok::Open::Sdk.configure do |config|
+  config.client_key             = Rails.application.credentials.dig(:tiktok, :client_key)
+  config.client_secret          = Rails.application.credentials.dig(:tiktok, :client_secret)
+  config.user_auth.scopes       = %w[user.info.basic video.publish]
+  config.user_auth.redirect_uri = "#{Rails.application.config.action_mailer.asset_host.chomp('/')}/users/auth/tiktok_open_sdk/callback"
+  config.load_omniauth          = true
+end
+```
+
+#### OmniAuth Callback
+
+Handle the OmniAuth callback in your controller:
+
+```ruby
+# app/controllers/omniauth_callbacks_controller.rb
+class OmniauthCallbacksController < Devise::OmniauthCallbacksController
+  def tiktok_open_sdk
+    @auth = request.env['omniauth.auth']
+
+    # Find or create user based on TikTok auth data
+    @user = User.find_for_oauth(@auth)
+
+    # ...
+
+    if @user.persisted?
+      sign_in_and_redirect @user, event: :authentication
+      set_flash_message :notice, :success, kind: 'TikTok'
+    else
+      session['devise.provider_data'] = @auth.except('extra')
+      redirect_to new_user_registration_url
+    end
+  end
+end
+```
+
+#### Supported Scopes
+
+The OmniAuth strategy supports the following TikTok scopes:
+
+- `user.info.basic` - Basic user info: open_id, union_id, display_name, avatar URLs
+- `user.info.profile` - Profile info: username, bio_description, profile_deep_link, is_verified
+- `user.info.stats` - Statistics: follower_count, following_count, likes_count, video_count
+
 ### Using the HTTP Client
 
 The SDK includes a flexible HTTP client for making API calls:
@@ -331,6 +463,8 @@ Tiktok::Open::Sdk.configure do |config|
   config.user_auth.scopes       = %w[user.info.basic]  # Optional
   config.user_auth.redirect_uri = 'https://...'        # Optional
   config.user_info_url          = 'https://open.tiktokapis.com/v2/user/info/' # Optional
+  config.creator_info_query_url = 'https://open.tiktokapis.com/v2/post/publish/creator_info/query/' # Optional
+  config.video_init_url         = 'https://open.tiktokapis.com/v2/post/publish/video/init/' # Optional
 end
 ```
 
@@ -410,20 +544,59 @@ Retrieves user information from the TikTok Open API.
 **Returns:** Hash with `:success`, `:code`, and `:response` keys
 
 **Available Fields:**
-- `open_id` - The unique identification of the user in the current application.Open id for the client
-- `union_id` - The unique identification of the user across different apps for the same developer. For example, if a partner has X number of clients, it will get X number of open_id for the same TikTok user, but one persistent union_id for the particular user
-- `avatar_url` - User's profile image
-- `avatar_url_100` - User`s profile image in 100x100 size
-- `avatar_large_url` - User's profile image with higher resolution
-- `display_name` - User's profile name
-- `bio_description` - User's bio description if there is a valid one
-- `profile_deep_link` - The link to user's TikTok profile page
-- `is_verified` - Whether TikTok has provided a verified badge to the account after confirming that it belongs to the user it represents
-- `username` - User's username
-- `follower_count` - User's followers count
-- `following_count` - The number of accounts that the user is following
-- `likes_count` - The total number of likes received by the user across all of their videos
-- `video_count` - The total number of publicly posted videos by the user
+- `open_id` - Unique identifier for the user within the current application
+- `union_id` - Persistent identifier for the user across different applications from the same developer
+- `avatar_url` - URL to the user's profile image
+- `avatar_url_100` - URL to the user's profile image in 100x100 pixel size
+- `avatar_large_url` - URL to the user's profile image in higher resolution
+- `display_name` - User's display name shown on their TikTok profile
+- `bio_description` - User's biography text (if available)
+- `profile_deep_link` - Direct link to the user's TikTok profile page
+- `is_verified` - Boolean indicating if the account is verified by TikTok
+- `username` - User's unique TikTok username
+- `follower_count` - Number of followers the user has
+- `following_count` - Number of accounts the user is following
+- `likes_count` - Total number of likes received across all user's videos
+- `video_count` - Total number of publicly posted videos by the user
+
+### Post API
+
+#### `creator_info_query(access_token:)`
+
+Queries creator information from the TikTok Open API for video publishing.
+
+**Parameters:**
+- `access_token` (String, required) - OAuth2 access token for authentication
+
+**Returns:** Hash with `:success`, `:code`, and `:response` keys
+
+**Response Data:**
+- `creator_avatar_url` - Creator's avatar URL
+- `creator_nickname` - Creator's display name
+- `creator_username` - Creator's username
+- `stitch_disabled` - Whether stitch is disabled for the creator
+- `comment_disabled` - Whether comments are disabled for the creator
+- `duet_disabled` - Whether duet is disabled for the creator
+- `max_video_post_duration_sec` - Maximum video duration in seconds
+- `privacy_level_options` - Available privacy level options
+
+#### `video_init(access_token:, params: {})`
+
+Initializes a video publish and returns a publish ID and upload URL (for file upload) or starts a pull-from-URL flow.
+
+**Parameters:**
+- `access_token` (String, required) - OAuth2 access token for authentication
+- `params` (Hash, required) - Request body with `post_info` and `source_info`
+  - `post_info` - Post metadata (title, privacy_level, disable_duet, disable_comment, disable_stitch, video_cover_timestamp_ms, etc.)
+  - `source_info` - Video source (e.g. `source: 'FILE_UPLOAD'` with video_size, chunk_size, total_chunk_count, video_type; or `source: 'PULL_FROM_URL'` with video_url)
+
+**Returns:** Hash with `:success`, `:code`, and `:response` keys
+
+**Response Data (on success):**
+- `data.publish_id` - Publish session ID
+- `data.upload_url` - URL for uploading video chunks (when using FILE_UPLOAD)
+
+**Raises:** `Tiktok::Open::Sdk::RequestValidationError` if access token is invalid or params fail validation
 
 ### HTTP Client
 

data/lib/tiktok/open/omniauth/strategies/tiktok_open_sdk.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Tiktok
+  module Open
+    module Omniauth
+      module Strategies
+        # OmniAuth strategy for TikTok Open Platform.
+        #
+        # Integrates TikTok OAuth2 authentication with OmniAuth.
+        #
+        # @example
+        #   use OmniAuth::Builder do
+        #     provider :tiktok_open, 'CLIENT_KEY', 'CLIENT_SECRET'
+        #   end
+        #
+        # Supported scopes and their user info fields:
+        #   - user.info.basic:   open_id, union_id, display_name, avatar_url, avatar_url_100, avatar_large_url
+        #   - user.info.profile: profile_deep_link, bio_description, is_verified, username
+        #   - user.info.stats:   follower_count, following_count, likes_count, video_count
+        class TiktokOpenSdk < ::OmniAuth::Strategies::OAuth2
+          # Custom access token class for TikTok.
+          class AccessToken < ::OAuth2::AccessToken; end
+
+          # Maps TikTok OAuth scopes to user info fields.
+          SCOPE_FIELDS = {
+            'user.info.basic'   => %w[open_id union_id display_name avatar_url avatar_url_100 avatar_large_url],
+            'user.info.profile' => %w[profile_deep_link bio_description is_verified username],
+            'user.info.stats'   => %w[follower_count following_count likes_count video_count]
+          }.freeze
+
+          private_constant :SCOPE_FIELDS
+
+          # The name of this OmniAuth strategy.
+          option :name, :tiktok_open_sdk
+
+          # OAuth2 client options for TikTok endpoints.
+          #   - :site: TikTok Open API base URL
+          #   - :authorize_url: TikTok OAuth2 authorization endpoint
+          #   - :token_url: TikTok OAuth2 token endpoint
+          option :client_options, {
+            site:             ::Tiktok::Open::Sdk::Config::OPEN_API_BASE_URL,
+            authorize_url:    ::Tiktok::Open::Sdk.config.user_auth.auth_url,
+            token_url:        ::Tiktok::Open::Sdk.config.user_auth.token_url,
+            auth_scheme:      :request_body,
+            auth_token_class: AccessToken
+          }
+
+          # List of parameters allowed in the authorization request.
+          option :authorize_options, %i[scope state redirect_uri]
+
+          # Default scope and redirect_uri from SDK config.
+          option :scope, ::Tiktok::Open::Sdk.config.user_auth.scopes.join(',')
+          option :redirect_uri, ::Tiktok::Open::Sdk.config.user_auth.redirect_uri
+
+          # Returns the unique TikTok user ID (open_id).
+          #
+          # @return [String] TikTok user's open_id.
+          uid { raw_info[:open_id].to_s }
+
+          # Returns a hash of user information.
+          #
+          # @return [Hash] User info with :name and :image keys, and profile fields if scope is present.
+          info do
+            { name: raw_info[:display_name], image: raw_info[:avatar_url_100] }.tap do |info|
+              if request_scopes.include?('user.info.profile')
+                info.merge!(raw_info.slice(:username, :bio_description, :profile_deep_link))
+              end
+            end
+          end
+
+          # Returns extra raw user information from TikTok.
+          #
+          # @return [Hash] Raw user info data from TikTok API.
+          extra { raw_info }
+
+          # Returns the callback URL without query parameters.
+          #
+          # @return [String] Callback URL.
+          def callback_url
+            super.split('?').first
+          end
+
+          # Builds the access token from TikTok's token endpoint.
+          #
+          # @raise [OAuth2::Error] if the token response is unsuccessful.
+          # @return [AccessToken] OAuth2 access token object.
+          def build_access_token
+            response = fetch_access_token
+            validate_token_response(response)
+            create_access_token(response[:response])
+          end
+
+          # Handles the initial OAuth2 request phase.
+          #
+          # @raise [ArgumentError] if client_secret is present in params.
+          def request_phase
+            params = authorize_params.merge('response_type' => 'code')
+
+            if params.key?(:client_secret) || params.key?('client_secret')
+              raise ArgumentError, 'client_secret is not allowed in authorize URL query params'
+            end
+
+            redirect client.authorize_url(params)
+          end
+
+          # Builds the authorization parameters for the OAuth2 request,
+          # adding the TikTok client_key.
+          #
+          # @return [Hash] Authorization parameters.
+          def authorize_params
+            super.tap do |params|
+              params[:client_key] = options.client_id
+            end
+          end
+
+          private
+
+          # Fetches access token from TikTok API
+          #
+          # @return [Hash] Token response from TikTok
+          def fetch_access_token
+            Tiktok::Open::Sdk.user_auth.fetch_access_token(
+              code:         request.params['code'],
+              redirect_uri: callback_url
+            )
+          end
+
+          # Validates the token response
+          #
+          # @param response [Hash] Token response
+          # @raise [OAuth2::Error] if response is unsuccessful
+          def validate_token_response(response)
+            raise OAuth2::Error, response[:response] unless response[:success]
+          end
+
+          # Creates AccessToken from response data
+          #
+          # @param data [Hash] Token data from response
+          # @return [AccessToken] OAuth2 access token object
+          def create_access_token(data)
+            AccessToken.from_hash(
+              client,
+              access_token:  data[:access_token],
+              refresh_token: data[:refresh_token],
+              expires_at:    Time.now.to_i + data[:expires_in].to_i
+            )
+          end
+
+          # Returns the list of requested OAuth scopes.
+          #
+          # @return [Array<String>] List of scope strings.
+          def request_scopes
+            @request_scopes ||= request.params.fetch('scopes', 'user.info.basic').split(',')
+          end
+
+          # Returns the list of user info fields to request from TikTok,
+          # based on the requested scopes.
+          #
+          # @return [Array<String>] List of user info field names.
+          def user_info_fields
+            request_scopes.flat_map { |scope| SCOPE_FIELDS[scope] }.compact
+          end
+
+          # Fetches and memoizes the raw user info from the TikTok API.
+          #
+          # @return [Hash] Raw user info data, or empty hash if unavailable.
+          def raw_info
+            @raw_info ||= Tiktok::Open::Sdk.user.get_user_info(
+              access_token: access_token.token,
+              fields:       user_info_fields
+            ).dig(:response, :data, :user) || {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tiktok/open/sdk/config.rb

@@ -29,14 +29,29 @@ module Tiktok
         #   @return [String] TikTok user info endpoint URL.
         attr_accessor :user_info_url
 
+        # @!attribute [rw] creator_info_query_url
+        #   @return [String] TikTok Query Creator Info endpoint URL.
+        attr_accessor :creator_info_query_url
+
+        # @!attribute [rw] video_init_url
+        #   @return [String] TikTok Video Init endpoint URL.
+        attr_accessor :video_init_url
+
         # @!attribute [rw] user_auth
         #   @return [UserAuth] User authentication configuration.
         attr_accessor :user_auth
 
+        # @!attribute [rw] load_omniauth
+        #   @return [Boolean] Whether to automatically load OmniAuth strategy.
+        attr_accessor :load_omniauth
+
         # Create a new Config with default user authentication settings.
         def initialize
-          @user_info_url = "#{OPEN_API_BASE_URL}/v2/user/info/"
-          @user_auth     = UserAuth.new
+          @user_info_url          = "#{OPEN_API_BASE_URL}/v2/user/info/"
+          @creator_info_query_url = "#{OPEN_API_BASE_URL}/v2/post/publish/creator_info/query/"
+          @video_init_url         = "#{OPEN_API_BASE_URL}/v2/post/publish/video/init/"
+          @user_auth              = UserAuth.new
+          @load_omniauth          = false
         end
 
         # User authentication configuration for TikTok Open SDK.

data/lib/tiktok/open/sdk/helpers/validators/post_info_validator.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Tiktok
+  module Open
+    module Sdk
+      module Helpers
+        module Validators
+          # Validates post information for TikTok video publishing.
+          #
+          # This module provides validation methods for post-related parameters including
+          # privacy level, title, boolean flags, and video cover timestamp.
+          #
+          # @example Including the validator in a class
+          #   class VideoPublisher
+          #     include Tiktok::Open::Sdk::Helpers::Validators::PostInfoValidator
+          #
+          #     def publish(post_info)
+          #       validate_post_info!(post_info)
+          #       # proceed with publishing
+          #     end
+          #   end
+          #
+          # @example Validating post information
+          #   post_info = {
+          #     privacy_level: 'PUBLIC_TO_EVERYONE',
+          #     title: 'My awesome video',
+          #     disable_duet: false,
+          #     brand_content_toggle: true
+          #   }
+          #   validate_post_info!(post_info)
+          module PostInfoValidator
+            # Valid privacy level options for TikTok videos
+            PRIVACY_LEVEL_OPTIONS = %w[
+              PUBLIC_TO_EVERYONE
+              MUTUAL_FOLLOW_FRIENDS
+              FOLLOWER_OF_CREATOR
+              SELF_ONLY
+            ].freeze
+
+            # Maximum allowed length for video title
+            MAX_TITLE_LENGTH = 2200
+
+            # Validates post information and raises an error if invalid.
+            #
+            # @param post_info [Hash, nil] The post information to validate
+            # @option post_info [String] :privacy_level Required. Must be one of PRIVACY_LEVEL_OPTIONS
+            # @option post_info [String] :title Optional. Maximum 2200 characters
+            # @option post_info [Boolean] :disable_duet Optional. Boolean flag
+            # @option post_info [Boolean] :disable_stitch Optional. Boolean flag
+            # @option post_info [Boolean] :disable_comment Optional. Boolean flag
+            # @option post_info [Boolean] :brand_content_toggle Optional. Boolean flag
+            # @option post_info [Boolean] :brand_organic_toggle Optional. Boolean flag
+            # @option post_info [Boolean] :is_aigc Optional. Boolean flag
+            # @option post_info [Integer] :video_cover_timestamp_ms Optional. Non-negative integer
+            #
+            # @return [void]
+            # @raise [Tiktok::Open::Sdk::RequestValidationError] If validation fails
+            #
+            # @example Valid post information
+            #   validate_post_info!(privacy_level: 'PUBLIC_TO_EVERYONE')
+            #
+            # @example Invalid privacy level
+            #   validate_post_info!(privacy_level: 'INVALID')
+            #   # => raises RequestValidationError with privacy_level error
+            def validate_post_info!(post_info)
+              errors = {}
+
+              validate_post_info(post_info, errors)
+
+              raise_validation_errors!(errors)
+            end
+
+            private
+
+            # Raises validation errors if any exist.
+            #
+            # @param errors [Hash] The accumulated validation errors
+            # @return [void]
+            # @raise [Tiktok::Open::Sdk::RequestValidationError] If errors is not empty
+            def raise_validation_errors!(errors)
+              raise ::Tiktok::Open::Sdk::RequestValidationError, errors unless errors.empty?
+            end
+
+            # Validates post information and accumulates errors.
+            #
+            # @param post_info [Hash, nil] The post information to validate
+            # @param errors [Hash] The hash to accumulate errors into
+            # @return [void]
+            def validate_post_info(post_info, errors)
+              return if post_info.nil?
+              return add_error errors, :post_info, 'must be a Hash' unless post_info.is_a?(Hash)
+
+              privacy_level = post_info[:privacy_level]
+              title         = post_info[:title]
+              timestamp     = post_info[:video_cover_timestamp_ms]
+
+              validate_privacy_level!         privacy_level, errors
+              validate_title!                 title,         errors
+              validate_boolean_fields!        post_info,     errors
+              validate_video_cover_timestamp! timestamp,     errors
+            end
+
+            # Validates that privacy level is one of the allowed options.
+            #
+            # @param privacy_level [String, nil] The privacy level to validate
+            # @param errors [Hash] The hash to accumulate errors into
+            # @return [void]
+            def validate_privacy_level!(privacy_level, errors)
+              return if PRIVACY_LEVEL_OPTIONS.include?(privacy_level)
+
+              add_error errors, :privacy_level, "must be one of: #{PRIVACY_LEVEL_OPTIONS.join(", ")}"
+            end
+
+            # Validates video title length and type.
+            #
+            # @param title [String, nil] The title to validate
+            # @param errors [Hash] The hash to accumulate errors into
+            # @return [void]
+            def validate_title!(title, errors)
+              return if title.nil?
+              return add_error errors, :title, 'must be a String' unless title.is_a?(String)
+              return unless title.length > MAX_TITLE_LENGTH
+
+              add_error errors, :title, "must be less than #{MAX_TITLE_LENGTH} characters"
+            end
+
+            # Validates that boolean fields contain boolean values.
+            #
+            # @param post_info [Hash] The post information containing boolean fields
+            # @param errors [Hash] The hash to accumulate errors into
+            # @return [void]
+            def validate_boolean_fields!(post_info, errors)
+              boolean_fields = %i[
+                disable_duet
+                disable_stitch
+                disable_comment
+                brand_content_toggle
+                brand_organic_toggle
+                is_aigc
+              ]
+
+              boolean_fields.each do |field|
+                next unless post_info.key?(field)
+
+                value = post_info[field]
+                next if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+                add_error errors, field, 'must be a boolean (true or false)'
+              end
+            end
+
+            # Validates video cover timestamp is a non-negative integer.
+            #
+            # @param timestamp [Integer, nil] The timestamp to validate
+            # @param errors [Hash] The hash to accumulate errors into
+            # @return [void]
+            def validate_video_cover_timestamp!(timestamp, errors)
+              return if timestamp.nil? || (timestamp.is_a?(Integer) && timestamp >= 0)
+
+              add_error errors, :video_cover_timestamp_ms, 'must be a non-negative integer'
+            end
+
+            # Adds an error message to the errors hash.
+            #
+            # @param errors [Hash] The hash to accumulate errors into
+            # @param field_name [Symbol] The field name that has an error
+            # @param message [String] The error message
+            # @return [Hash] The errors hash
+            def add_error(errors, field_name, message)
+              errors[field_name] ||= [] << message
+              errors
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tiktok/open/sdk/helpers/validators/post_publish_validator.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'post_info_validator'
+require_relative 'source_info_validator'
+
+module Tiktok
+  module Open
+    module Sdk
+      module Helpers
+        module Validators
+          # Provides validation for video publishing initialization parameters.
+          #
+          # This module combines and applies the `PostInfoValidator` and `SourceInfoValidator` logic
+          # for validating `post_info` and `source_info` input hashes typically required for
+          # TikTok Open SDK video publishing workflows.
+          #
+          # @example Including and using PostPublishValidator
+          #   class Publisher
+          #     include Tiktok::Open::Sdk::Helpers::Validators::PostPublishValidator
+          #
+          #     def publish_video(params)
+          #       validate_video_init_info!(params)
+          #       # ...proceed if valid
+          #     end
+          #   end
+          #
+          # @see PostInfoValidator#validate_post_info
+          # @see SourceInfoValidator#validate_source_info
+          module PostPublishValidator
+            include PostInfoValidator
+            include SourceInfoValidator
+
+            # Validates combined video initialization parameters.
+            #
+            # Both `post_info` and `source_info` sub-hashes are validated using the appropriate
+            # validators. If any errors occur, a RequestValidationError (or similar) is raised.
+            #
+            # @param params [Hash] The full parameter hash.
+            # @option params [Hash] :post_info Info for video post, validated by PostInfoValidator
+            # @option params [Hash] :source_info Info on video source, validated by SourceInfoValidator
+            #
+            # @raise [RequestValidationError] Raised if any validation errors found in either section.
+            # @return [void]
+            def validate_video_init_info!(params)
+              errors = { post_info: {}, source_info: {} }
+
+              validate_post_info   params[:post_info],   errors[:post_info]
+              validate_source_info params[:source_info], errors[:source_info]
+
+              raise_validation_errors!(errors) unless errors.values.all?(&:empty?)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tiktok/open/sdk/helpers/validators/source_info_validator.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Tiktok
+  module Open
+    module Sdk
+      module Helpers
+        module Validators
+          # Validates source information for TikTok video publishing.
+          #
+          # This module provides validation methods for video source parameters including
+          # source type (PULL_FROM_URL or FILE_UPLOAD) and their respective required fields.
+          #
+          # @example Including the validator in a class
+          #   class VideoPublisher
+          #     include Tiktok::Open::Sdk::Helpers::Validators::SourceInfoValidator
+          #
+          #     def publish(source_info)
+          #       validate_source_info!(source_info)
+          #       # proceed with publishing
+          #     end
+          #   end
+          #
+          # @example Validating PULL_FROM_URL source
+          #   source_info = {
+          #     source: 'PULL_FROM_URL',
+          #     video_url: 'https://example.com/video.mp4'
+          #   }
+          #   validate_source_info!(source_info)
+          #
+          # @example Validating FILE_UPLOAD source
+          #   source_info = {
+          #     source: 'FILE_UPLOAD',
+          #     video_size: 10_485_760,
+          #     chunk_size: 1_048_576,
+          #     total_chunk_count: 10
+          #   }
+          #   validate_source_info!(source_info)
+          module SourceInfoValidator
+            # Valid source options for video uploads
+            SOURCE_OPTIONS = %w[
+              PULL_FROM_URL
+              FILE_UPLOAD
+            ].freeze
+
+            # Validates source information and raises an error if invalid.
+            #
+            # @param source_info [Hash, nil] The source information to validate
+            # @option source_info [String] :source Required. Must be 'PULL_FROM_URL' or 'FILE_UPLOAD'
+            # @option source_info [String] :video_url Required for PULL_FROM_URL. Non-empty video URL
+            # @option source_info [Integer] :video_size Required for FILE_UPLOAD. Positive integer
+            # @option source_info [Integer] :chunk_size Optional for FILE_UPLOAD. Positive integer
+            # @option source_info [Integer] :total_chunk_count Optional for FILE_UPLOAD. Positive integer
+            #
+            # @return [void]
+            # @raise [Tiktok::Open::Sdk::RequestValidationError] If validation fails
+            #
+            # @example Valid PULL_FROM_URL source
+            #   validate_source_info!(source: 'PULL_FROM_URL', video_url: 'https://example.com/video.mp4')
+            #
+            # @example Valid FILE_UPLOAD source
+            #   validate_source_info!(source: 'FILE_UPLOAD', video_size: 10_485_760)
+            #
+            # @example Invalid source type
+            #   validate_source_info!(source: 'INVALID')
+            #   # => raises RequestValidationError with source error
+            def validate_source_info!(source_info)
+              errors = {}
+
+              validate_source_info(source_info, errors)
+
+              raise_validation_errors!(errors)
+            end
+
+            private
+
+            # Raises validation errors if any exist.
+            #
+            # @param errors [Hash] The accumulated validation errors
+            # @return [void]
+            # @raise [Tiktok::Open::Sdk::RequestValidationError] If errors is not empty
+            def raise_validation_errors!(errors)
+              raise ::Tiktok::Open::Sdk::RequestValidationError, errors unless errors.empty?
+            end
+
+            # Validates source information and accumulates errors.
+            #
+            # @param source_info [Hash, nil] The source information to validate
+            # @param errors [Hash] The hash to accumulate errors into
+            # @return [void]
+            def validate_source_info(source_info, errors)
+              if source_info.is_a?(Hash)
+                validate_source_specific_fields!(source_info, errors)
+              else
+                add_error errors, :source_info, 'must be a Hash'
+              end
+            end
+
+            # Validates source-specific required fields based on source type.
+            #
+            # @param source_info [Hash] The source information containing type-specific fields
+            # @param errors [Hash] The hash to accumulate errors into
+            # @return [void]
+            def validate_source_specific_fields!(source_info, errors)
+              case source_info[:source]
+              when 'PULL_FROM_URL'
+                validate_pull_from_url_fields!(source_info, errors)
+              when 'FILE_UPLOAD'
+                validate_file_upload_fields!(source_info, errors)
+              else
+                add_error errors, :source, "must be one of: #{SOURCE_OPTIONS.join(", ")}"
+              end
+            end
+
+            # Validates required fields for PULL_FROM_URL source type.
+            #
+            # @param source_info [Hash] The source information
+            # @param errors [Hash] The hash to accumulate errors into
+            # @return [void]
+            def validate_pull_from_url_fields!(source_info, errors)
+              video_url = source_info[:video_url]
+
+              return if video_url.is_a?(String) && !video_url.empty?
+
+              add_error errors, :video_url, 'is required and must be a non-empty string for PULL_FROM_URL'
+            end
+
+            # Validates required fields for FILE_UPLOAD source type.
+            #
+            # @param source_info [Hash] The source information
+            # @param errors [Hash] The hash to accumulate errors into
+            # @return [void]
+            def validate_file_upload_fields!(source_info, errors)
+              validate_video_size!        source_info[:video_size],        errors
+              validate_chunk_size!        source_info[:chunk_size],        errors
+              validate_total_chunk_count! source_info[:total_chunk_count], errors
+            end
+
+            # Validates video size for FILE_UPLOAD source.
+            #
+            # @param video_size [Integer, nil] The video size in bytes
+            # @param errors [Hash] The hash to accumulate errors into
+            # @return [void]
+            def validate_video_size!(video_size, errors)
+              return if video_size.is_a?(Integer) && video_size.positive?
+
+              add_error errors, :video_size, 'is required and must be a positive integer for FILE_UPLOAD'
+            end
+
+            # Validates chunk size for FILE_UPLOAD source.
+            #
+            # @param value [Integer, nil] The chunk size in bytes
+            # @param errors [Hash] The hash to accumulate errors into
+            # @return [void]
+            def validate_chunk_size!(value, errors)
+              return if value.nil? || (value.is_a?(Integer) && value.positive?)
+
+              add_error errors, :chunk_size, 'must be a positive integer if provided'
+            end
+
+            # Validates total chunk count for FILE_UPLOAD source.
+            #
+            # @param value [Integer, nil] The total number of chunks
+            # @param errors [Hash] The hash to accumulate errors into
+            # @return [void]
+            def validate_total_chunk_count!(value, errors)
+              return if value.nil? || (value.is_a?(Integer) && value.positive?)
+
+              add_error errors, :total_chunk_count, 'must be a positive integer if provided'
+            end
+
+            # Adds an error message to the errors hash.
+            #
+            # @param errors [Hash] The hash to accumulate errors into
+            # @param field_name [Symbol] The field name that has an error
+            # @param message [String] The error message
+            # @return [Hash] The errors hash
+            def add_error(errors, field_name, message)
+              errors[field_name] ||= [] << message
+              errors
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tiktok/open/sdk/http_client.rb

@@ -85,7 +85,7 @@ module Tiktok
           case content_type
           when 'application/x-www-form-urlencoded'
             request.set_form_data(body)
-          when 'application/json'
+          when 'application/json', 'application/json; charset=UTF-8'
             request.body = body.to_json
           else
             raise ArgumentError, "Unsupported content type: #{content_type}"
@@ -102,10 +102,11 @@ module Tiktok
         # @param body [Hash, nil] The request body.
         # @return [Net::HTTPRequest] The HTTP request object.
         def build_http_request(method, uri, headers, body)
-          klass   = Net::HTTP.const_get(method.capitalize)
-          request = klass.new(uri, headers)
+          klass        = Net::HTTP.const_get(method.capitalize)
+          request      = klass.new(uri, headers)
+          content_type = headers[:'Content-Type'] || headers['Content-Type']
 
-          body ? assign_body!(request, body, headers[:'Content-Type']) : request
+          body ? assign_body!(request, body, content_type) : request
         end
       end
     end

data/lib/tiktok/open/sdk/open_api/auth/user.rb

@@ -23,7 +23,7 @@ module Tiktok
             # @return [URI] The constructed authorization URI.
             def authorization_uri(params = {})
               allowed_params = params.slice(:scope, :redirect_uri, :state)
-              uri            = URI(Tiktok::Open::Sdk.config.user_auth.auth_url)
+              uri            = URI.parse(Tiktok::Open::Sdk.config.user_auth.auth_url)
               query_params   = authorization_uri_default_params.merge(allowed_params)
               uri.query      = URI.encode_www_form(query_params)
 

data/lib/tiktok/open/sdk/open_api/post/publish.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Provides methods to interact with TikTok Open API post endpoints.
+module Tiktok
+  module Open
+    module Sdk
+      module OpenApi
+        module Post
+          # Provides methods for handling TikTok Open API post endpoints.
+          module Publish
+            extend self
+
+            include ::Tiktok::Open::Sdk::Helpers::ResponseHelper
+            include ::Tiktok::Open::Sdk::Helpers::Validators::TokenValidator
+            include ::Tiktok::Open::Sdk::Helpers::Validators::PostPublishValidator
+
+            # Queries creator information from the TikTok Open API.
+            #
+            # @param access_token [String] OAuth2 access token for authentication.
+            # @return [Hash] Parsed API response containing creator information.
+            # @raise [::Tiktok::Open::Sdk::RequestValidationError] If the access token is invalid.
+            #
+            # @example
+            #   Tiktok::Open::Sdk.post.creator_info_query(access_token: 'your_access_token')
+            def creator_info_query(access_token:)
+              validate_token!(access_token)
+
+              render_response Tiktok::Open::Sdk::HttpClient.post(
+                Tiktok::Open::Sdk.config.creator_info_query_url,
+                headers: {
+                  Authorization: "Bearer #{access_token}"
+                }
+              )
+            end
+
+            def video_init(access_token:, params: {})
+              validate_token!(access_token)
+              validate_video_init_info!(params)
+
+              render_response Tiktok::Open::Sdk::HttpClient.post(
+                Tiktok::Open::Sdk.config.video_init_url,
+                headers: {
+                  Authorization:  "Bearer #{access_token}",
+                  'Content-Type': 'application/json; charset=UTF-8'
+                },
+                body:    params
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tiktok/open/sdk/version.rb

@@ -3,7 +3,7 @@
 module Tiktok
   module Open
     module Sdk
-      VERSION = '0.3.0'
+      VERSION = '0.5.0'
     end
   end
 end

data/lib/tiktok/open/sdk.rb

@@ -4,8 +4,10 @@ require_relative 'sdk/helpers/string_utils_helper'
 require_relative 'sdk/helpers/response_helper'
 require_relative 'sdk/helpers/auth_helper'
 require_relative 'sdk/helpers/validators/token_validator'
+require_relative 'sdk/helpers/validators/post_publish_validator'
 require_relative 'sdk/open_api/auth/user'
 require_relative 'sdk/open_api/auth/client'
+require_relative 'sdk/open_api/post/publish'
 require_relative 'sdk/open_api/user'
 require_relative 'sdk/version'
 require_relative 'sdk/http_client'
@@ -21,7 +23,31 @@ module Tiktok
       #   raise Tiktok::Open::Sdk::Error, "Something went wrong"
       class Error < StandardError; end
 
-      class RequestValidationError < Error; end
+      # Error class for request validation failures
+      #
+      # This error is raised when request validation fails, providing access to
+      # detailed validation error information.
+      #
+      # @attr_reader messages [Hash, nil] validation errors hash or nil if no specific errors
+      #
+      # @example
+      #   raise RequestValidationError.new({ field: ['error message'] })
+      #   raise RequestValidationError.new('General validation error')
+      class RequestValidationError < Error
+        attr_reader :messages
+
+        def initialize(messages = nil)
+          if messages.is_a?(Hash)
+            @messages = messages
+
+            super('Validation failed')
+          else
+            @messages = nil
+
+            super
+          end
+        end
+      end
 
       class << self
         # SDK configuration object
@@ -45,12 +71,15 @@ module Tiktok
         #     config.user_auth.token_url = 'https://open.tiktokapis.com/v2/oauth/token/'
         #     config.user_auth.scopes = %w[user.info.basic video.list]
         #     config.user_auth.redirect_uri = 'https://your-redirect-uri.example.com'
+        #     config.load_omniauth = true
         #   end
         def configure
           self.config ||= Config.new
 
           yield(config)
 
+          load_omniauth! if config.load_omniauth
+
           config
         end
 
@@ -73,6 +102,44 @@ module Tiktok
         def client_auth
           OpenApi::Auth::Client
         end
+
+        # Convenience accessor for post publish functionality
+        #
+        # @return [OpenApi::Post::Publish] the Post publish module
+        #
+        # @example
+        #   Tiktok::Open::Sdk.post.video_init(access_token: 'token', post_info: post_info, source_info: source_info)
+        def post
+          OpenApi::Post::Publish
+        end
+
+        # Convenience accessor for user functionality
+        #
+        # @return [OpenApi::User] the User module
+        #
+        # @example
+        #   Tiktok::Open::Sdk.user.info(access_token: 'token')
+        def user
+          OpenApi::User
+        end
+
+        private
+
+        # Loads the OmniAuth strategy for TikTok Open Platform.
+        #
+        # Attempts to require the necessary OmniAuth dependencies for TikTok Open integration.
+        # Raises an error if the required gems are not available.
+        #
+        # @raise [Tiktok::Open::Sdk::Error] if 'omniauth-oauth2' or the TikTok strategy cannot be loaded
+        # @example
+        #   Tiktok::Open::Sdk.load_omniauth!
+        def load_omniauth!
+          require 'omniauth-oauth2'
+          require 'tiktok/open/omniauth/strategies/tiktok_open_sdk'
+        rescue LoadError => e
+          raise ::Tiktok::Open::Sdk::Error,
+                "OmniAuth is not loaded! Error: #{e.message}"
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tiktok-open-sdk
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Taras Pochkun
@@ -26,15 +26,20 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/tiktok/open/omniauth/strategies/tiktok_open_sdk.rb
 - lib/tiktok/open/sdk.rb
 - lib/tiktok/open/sdk/config.rb
 - lib/tiktok/open/sdk/helpers/auth_helper.rb
 - lib/tiktok/open/sdk/helpers/response_helper.rb
 - lib/tiktok/open/sdk/helpers/string_utils_helper.rb
+- lib/tiktok/open/sdk/helpers/validators/post_info_validator.rb
+- lib/tiktok/open/sdk/helpers/validators/post_publish_validator.rb
+- lib/tiktok/open/sdk/helpers/validators/source_info_validator.rb
 - lib/tiktok/open/sdk/helpers/validators/token_validator.rb
 - lib/tiktok/open/sdk/http_client.rb
 - lib/tiktok/open/sdk/open_api/auth/client.rb
 - lib/tiktok/open/sdk/open_api/auth/user.rb
+- lib/tiktok/open/sdk/open_api/post/publish.rb
 - lib/tiktok/open/sdk/open_api/user.rb
 - lib/tiktok/open/sdk/version.rb
 - sig/tiktok/open/sdk.rbs
@@ -44,7 +49,7 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/pochkuntaras/tiktok-open-sdk
-  source_code_uri: https://github.com/pochkuntaras/tiktok-open-sdk
+  source_code_uri: https://github.com/pochkuntaras/tiktok-open-sdk.git
   changelog_uri: https://github.com/pochkuntaras/tiktok-open-sdk/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
   documentation_uri: https://rubydoc.info/gems/tiktok-open-sdk