fastpixapi 0.0.1 → 1.1.0

data/lib/fastpix_client/start_live_stream.rb

@@ -0,0 +1,194 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'faraday'
+require 'faraday/multipart'
+require 'faraday/retry'
+require 'sorbet-runtime'
+require_relative 'sdk_hooks/hooks'
+require_relative 'utils/retries'
+
+module FastpixClient
+  extend T::Sig
+  class StartLiveStream
+    extend T::Sig
+    
+    # Operations for starting live streams
+
+    sig { params(sdk_config: SDKConfiguration).void }
+    def initialize(sdk_config)
+      @sdk_configuration = sdk_config
+      
+    end
+
+    sig { params(base_url: String, url_variables: T.nilable(T::Hash[Symbol, T.any(String, T::Enum)])).returns(String) }
+    def get_url(base_url:, url_variables: nil)
+      sd_base_url, sd_options = @sdk_configuration.get_server_details
+
+      if base_url.nil?
+        base_url = sd_base_url
+      end
+
+      if url_variables.nil?
+        url_variables = sd_options
+      end
+
+      return Utils.template_url base_url, url_variables
+    end
+
+
+    sig { params(request: Models::Components::CreateLiveStreamRequest, timeout_ms: T.nilable(Integer)).returns(Models::Operations::CreateNewStreamResponse) }
+    def create_new_stream(request:, timeout_ms: nil)
+      # create_new_stream - Create a new stream
+      # Creates a new <a href="https://docs.fastpix.io/docs/get-started-with-live-streaming">RTMPS</a> or <a href="https://docs.fastpix.io/docs/using-srt-to-live-stream">SRT</a> live stream in FastPix. When you create a stream, FastPix generates a unique `streamKey` and `srtSecret` that you can use with broadcasting software such as OBS to connect to FastPix RTMPS or SRT servers. Use SRT for live streaming in unstable network conditions, as it provides error correction and encryption for a more reliable and secure broadcast.
+      # 
+      # Leverage SRT for live streaming in environments with unstable networks, taking advantage of its error correction and encryption features for a resilient and secure broadcast. 
+      # 
+      # <h4>How it works</h4> 
+      # 
+      # 1. Send a `POST` request to this endpoint. You can configure the stream settings, including `metadata` (such as stream name and description), `reconnectWindow` (in case of disconnection), and privacy options (`public` or `private`). 
+      # 
+      # 2. FastPix returns the stream details for both RTMPS and SRT configurations. These keys and IDs from the stream details are essential for connecting the broadcasting software to FastPix’s servers and transmitting the live stream to viewers.
+      # 
+      # 3. After the live stream is created, FastPix sends a `POST` request to your specified webhook endpoint with the event <a href="https://docs.fastpix.io/docs/live-events#videolive_streamcreated">video.live_stream.created</a>.
+      # 
+      # 
+      # **Example:**
+      # 
+      # 
+      #   Imagine a gaming platform that allows users to live stream gameplay directly from their dashboard. The API creates a new stream, provides the necessary stream key, and sets it to "private" so that only specific viewers can access it. 
+      # 
+      # 
+      # Related guide: <a href="https://docs.fastpix.io/docs/how-to-livestream">How to live stream</a>
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = "#{base_url}/live/streams"
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      req_content_type, data, form = Utils.serialize_request_body(request, false, false, :request, :json)
+      headers['content-type'] = req_content_type
+      raise StandardError, 'request body is required' if data.nil? && form.nil?
+
+      if form
+        body = Utils.encode_form(form)
+      elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
+        body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
+      else
+        body = data
+      end
+      headers['Accept'] = 'application/json'
+      headers['user-agent'] = @sdk_configuration.user_agent
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+      
+
+      connection = @sdk_configuration.client
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: nil,
+        operation_id: 'create-new-stream',
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+      
+      
+      begin
+        http_response = T.must(connection).post(url) do |req|
+          req.body = body
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          Utils.configure_request_security(req, security)
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+      rescue StandardError => e
+        error = e
+      ensure
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+        
+        if http_response.nil?
+          raise error if !error.nil?
+          raise 'no response'
+        end
+      end
+      
+      content_type = http_response.headers.fetch('Content-Type', 'application/octet-stream')
+      if Utils.match_status_code(http_response.status, ['201'])
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Components::LiveStreamResponseDTO)
+          response = Models::Operations::CreateNewStreamResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            live_stream_response_dto: T.unsafe(obj)
+          )
+
+          return response
+        else
+          raise ::FastpixClient::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      elsif Utils.match_status_code(http_response.status, ['4XX'])
+        raise ::FastpixClient::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      elsif Utils.match_status_code(http_response.status, ['5XX'])
+        raise ::FastpixClient::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'API error occurred'
+      else
+        if Utils.match_content_type(content_type, 'application/json')
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Components::DefaultError)
+          response = Models::Operations::CreateNewStreamResponse.new(
+            status_code: http_response.status,
+            content_type: content_type,
+            raw_response: http_response,
+            default_error: T.unsafe(obj)
+          )
+
+          return response
+        else
+          raise ::FastpixClient::Models::Errors::APIError.new(status_code: http_response.status, body: http_response.env.response_body, raw_response: http_response), 'Unknown content type received'
+        end
+      end
+    end
+  end
+end

data/lib/fastpix_client/utils/forms.rb

@@ -0,0 +1,206 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'cgi'
+require 'date'
+require 'base64'
+require 'sorbet-runtime'
+
+module FastpixClient
+  module Utils
+    extend T::Sig
+
+    sig do
+      params(field_name: String, explode: T::Boolean, obj: Object, delimiter: String,
+             get_field_name_lambda: T.proc.params(obj_field: ::Crystalline::MetadataFields::Field).returns(String))
+        .returns(T::Hash[String, T::Array[String]])
+    end
+    def self._populate_form(field_name, explode, obj, delimiter, &get_field_name_lambda)
+      params = {}
+
+      return params if obj.nil?
+
+      if obj.respond_to? :fields
+        items = []
+        T.unsafe(obj).fields.each do |obj_field|
+          obj_field_name = get_field_name_lambda.call(obj_field)
+          next if obj_field_name == ''
+
+          val = obj.send(obj_field.name.to_sym)
+          next if val.nil?
+
+          if explode
+            params[obj_field_name] = [val_to_string(val)]
+          else
+            items.append("#{obj_field_name}#{delimiter}#{val_to_string(val)}")
+          end
+        end
+
+        params[field_name] = [items.join(delimiter)] if !items.empty?
+      elsif obj.is_a? Hash
+        items = []
+        obj.each do |key, value|
+          next if value.nil?
+
+          if explode
+            params[key] = val_to_string(value)
+          else
+            items.append("#{key}#{delimiter}#{val_to_string(value)}")
+          end
+        end
+        params[field_name] = [items.join(delimiter)] if !items.empty?
+
+      elsif obj.is_a? Array
+        items = []
+        obj.each do |value|
+          next if value.nil?
+
+          if explode
+            params[field_name] = [] if !params.key? field_name
+
+            params[field_name].append(val_to_string(value))
+          else
+            items.append(val_to_string(value))
+          end
+        end
+        params[field_name] = items.map(&:to_s).join(delimiter) if !items.empty?
+
+      else
+        params[field_name] = val_to_string(obj)
+      end
+      params
+    end
+
+    sig { params(media_type: String, request: Object).returns([String, Object, T::Array[T::Array[T.any(T::Array[T.nilable(String)], String)]]]) }
+    def self.serialize_multipart_form(media_type, request)
+      form = []
+      T.unsafe(request).fields.each do |field|
+        val = request.send(field.name)
+        next if val.nil?
+
+        field_metadata = field.metadata[:multipart_form]
+        next if field_metadata.nil?
+
+        if field_metadata[:file] == true
+          field_name = field_metadata[:field_name]
+          
+          # Handle arrays of files
+          if val.is_a? Array
+            val.each do |file_obj|
+              file_name = T.let('', String)
+              content = nil
+
+              T.must(file_obj).fields.each do |file_field|
+                file_metadata = file_field.metadata[:multipart_form]
+                next if file_metadata.nil?
+
+                if file_metadata[:content] == true
+                  content = T.let(file_obj.send(file_field.name), String)
+                else
+                  file_name = T.let(file_obj.send(file_field.name), String)
+                end
+              end
+              raise StandardError, 'invalid multipart/form-data file' if T.unsafe(file_name) == '' || T.unsafe(content).nil?
+
+              form.append([field_name, [file_name, content]])
+            end
+          else
+            # Handle single file
+            file_name = T.let('', String)
+            content = nil
+
+            T.must(val).fields.each do |file_field|
+              file_metadata = file_field.metadata[:multipart_form]
+              next if file_metadata.nil?
+
+              if file_metadata[:content] == true
+                content = T.let(val.send(file_field.name), String)
+              else
+                file_name = T.let(val.send(file_field.name), String)
+              end
+            end
+            raise StandardError, 'invalid multipart/form-data file' if T.unsafe(file_name) == '' || T.unsafe(content).nil?
+
+            form.append([field_name, [file_name, content]])
+          end
+        elsif field_metadata[:json] == true
+          to_append = [
+            field_metadata.fetch(:field_name, field.name), [
+              nil, ::Crystalline.to_json(val), 'application/json'
+            ]
+          ]
+          form.append(to_append)
+        else
+          field_name = field_metadata.fetch(
+            :field_name, field.name
+          )
+          if val.is_a? Array
+            val.each do |value|
+              next if value.nil?
+
+              form.append(
+                [field_name, [nil, val_to_string(value)]]
+              )
+            end
+          else
+            form.append([field_name, [nil, val_to_string(val)]])
+          end
+        end
+      end
+      [media_type, nil, form]
+    end
+
+
+    sig do
+      params(data: T.any(Object, T::Hash[String, String]))
+        .returns(T::Hash[T.any(String, Symbol), Object])
+    end
+    def self.serialize_form_data(data)
+      get_form_field_name = lambda do |obj_field|
+        obj_param_metadata = obj_field.metadata[:form]
+
+        return T.let({}, T::Hash[T.any(String, Symbol), Object]) if obj_param_metadata.nil?
+
+        return obj_param_metadata.fetch(:field_name, obj_field.name)
+      end
+
+      form = T.let({}, T::Hash[T.any(String, Symbol), Object])
+      if data.respond_to? :fields
+        T.unsafe(data).fields.each do |field|
+          val = data.send(field.name)
+          next if val.nil?
+
+          metadata = field.metadata[:form]
+
+          next if metadata.nil?
+
+          field_name = metadata.fetch(:field_name, field.name)
+
+          if metadata[:json]
+            form[field_name] = ::Crystalline.to_json(val)
+          else
+            if metadata.fetch(:style, 'form') == 'form'
+              form = form.merge(
+                _populate_form(
+                  field_name, metadata.fetch(:explode, true), val, ',', &get_form_field_name
+                )
+              )
+            else
+              raise StandardError, "Invalid form style for field #{field.name}"
+            end
+          end
+        end
+      elsif data.is_a? Hash
+        data.each do |key, value|
+          form[key] = [val_to_string(value)]
+        end
+      else
+        raise StandardError, "Invalid request body type #{data.class}"
+      end
+
+      form
+    end
+  end
+end

data/lib/fastpix_client/utils/headers.rb

@@ -0,0 +1,77 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'cgi'
+require 'date'
+require 'base64'
+require 'sorbet-runtime'
+
+module FastpixClient
+  module Utils
+    extend T::Sig
+
+    sig { params(headers_params: Object, gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(T::Hash[Symbol, String]) }
+    def self.get_headers(headers_params, gbls = nil)
+      return {} if headers_params.nil?
+
+      headers = {}
+      T.unsafe(headers_params).fields.each do |f|
+        metadata = f.metadata[:header]
+        next if metadata.nil?
+
+        value = _populate_from_globals(f.name, headers_params&.send(f.name), 'header', gbls)
+        value = _serialize_header(metadata.fetch(:explode, false), value)
+        headers[metadata.fetch(:field_name, f.name)] = value if !T.must(value).empty?
+      end
+      headers
+    end
+
+    sig { params(explode: T::Boolean, obj: Object).returns(T.nilable(String)) }
+    def self._serialize_header(explode, obj)
+      return '' if obj.nil?
+
+      if obj.respond_to? :fields
+        items = []
+        T.unsafe(obj).fields.each do |obj_field|
+          obj_param_metadata = obj_field.metadata[:header]
+          next if obj_param_metadata.nil?
+
+          obj_field_name = obj_param_metadata.fetch(:field_name, obj_field.name)
+          next if obj_field_name == ''
+
+          val = obj.send(obj_field.name)
+          next if val.nil?
+
+          if explode
+            items.append("#{obj_field_name}=#{val_to_string(val)}")
+          else
+            items.append(obj_field_name)
+            items.append(val_to_string(val))
+          end
+        end
+
+        items.join(',') if !items.empty?
+      elsif obj.is_a? Hash
+        items = []
+        obj.each do |key, value|
+          next if value.nil?
+
+          if explode
+            items.append("#{key}=#{val_to_string(value)}")
+          else
+            items.append(key)
+            items.append(val_to_string(value))
+          end
+        end
+
+        items.join(',') if !items.empty?
+      elsif obj.is_a? Array
+        items = obj.filter { |v| !v.nil? }.map { |v| val_to_string(v) }.join(',')
+      else
+        val_to_string(obj)
+      end
+    end
+  end
+end

data/lib/fastpix_client/utils/query_params.rb

@@ -0,0 +1,133 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'date'
+require 'base64'
+require 'sorbet-runtime'
+
+module FastpixClient
+  module Utils
+    extend T::Sig
+
+    sig { params(clazz: Object, query_params: Object, url_override: T.nilable(::String), gbls: T.nilable(T::Hash[Symbol, T::Hash[Symbol, T::Hash[Symbol, Object]]])).returns(T::Hash[T.any(String, Symbol), T::Array[String]]) }
+    def self.get_query_params(clazz, query_params, url_override = nil, gbls = nil)
+      parsed_params = T.let({}, T::Hash[T.any(String, Symbol), T::Array[String]])
+      if !url_override.nil?
+        parsed_url = URI.parse url_override
+        URI.decode_www_form(parsed_url.query.to_s).each do |key, value|
+          parsed_params[key] ||= []
+          T.must(parsed_params[key]) << value
+        end
+      end
+      params = T.let({}, T::Hash[T.any(String, Symbol), T::Array[String]])
+      T.unsafe(clazz).fields.each do |f|
+        request_metadata = f.metadata[:request]
+        next if !request_metadata.nil?
+
+        metadata = f.metadata[:query_param]
+        next if metadata.nil?
+
+        param_name = f.name
+        value = query_params&.send(param_name.to_sym)
+        value = _populate_from_globals(param_name, value, 'queryParam', gbls)
+
+        f_name = metadata[:field_name]
+        serialization = metadata.fetch(:serialization, '')
+        if serialization != ''
+          params = params.merge _get_serialized_params(
+            metadata, f_name, value
+          )
+        else
+          style = metadata.fetch(:style, 'form')
+          case style
+          when 'deepObject'
+            params = params.merge _get_deep_object_query_params(
+              metadata, f_name, value
+            )
+          when 'form'
+            params = params.merge _get_delimited_query_params(
+              metadata, f_name, value, ','
+            )
+          when 'pipeDelimited'
+            params = params.merge _get_delimited_query_params(
+              metadata, f_name, value, '|'
+            )
+          else
+            raise StandardError, 'not yet implemented'
+          end
+        end
+      end
+      params.merge parsed_params
+    end
+
+    sig do
+      params(metadata: T::Hash[Symbol, String], field_name: String, obj: Object)
+        .returns(T::Hash[T.any(String, Symbol), T::Array[String]])
+    end
+    def self._get_deep_object_query_params(metadata, field_name, obj)
+      params = T.let({}, T::Hash[T.any(String, Symbol), T::Array[String]])
+
+      return params if obj.nil?
+
+      if obj.respond_to? :fields
+        T.unsafe(obj).fields.each do |obj_field|
+          obj_param_metadata = obj_field.metadata[:query_param]
+          next if obj_param_metadata.nil?
+
+          val = obj.send(obj_field.name)
+          next if val.nil?
+
+          key = "#{metadata.fetch(:field_name, field_name)}[#{obj_param_metadata.fetch(:field_name, obj_field.name)}]"
+          if val.is_a? Array
+            val.each do |v|
+              next if v.nil?
+
+              params[key] = [] if !params.include? key
+
+              T.must(params[key]) << val_to_string(v)
+            end
+          else
+            params[key] = [val_to_string(val)]
+          end
+        end
+      elsif obj.is_a? Hash
+        obj.each do |key, value|
+          next if value.nil?
+
+          param_key = "#{metadata.fetch(:field_name, field_name)}[#{key}]"
+          if value.is_a? Array
+            value.each do |val|
+              next if val.nil?
+
+              params[param_key] = [] if !params.include? param_key
+
+              T.must(params[param_key]).append(val_to_string(val))
+            end
+          else
+            params[param_key] = [val_to_string(value)]
+          end
+        end
+      end
+      params
+    end
+
+
+    sig do
+      params(metadata: T::Hash[Symbol, String], field_name: String, obj: Object, delimiter: String)
+        .returns(T::Hash[T.any(String, Symbol), T::Array[String]])
+    end
+    def self._get_delimited_query_params(metadata, field_name, obj, delimiter)
+      get_query_param_field_name = lambda do |obj_field|
+        obj_param_metadata = obj_field.metadata[:query_param]
+
+        return {} if obj_param_metadata.nil?
+
+        return obj_param_metadata.fetch(:field_name, obj_field.name)
+      end
+
+      _populate_form(field_name, T.cast(metadata.fetch(:explode, true), T::Boolean), obj, delimiter, &get_query_param_field_name)
+    end
+  end
+end

data/lib/fastpix_client/utils/request_bodies.rb

@@ -0,0 +1,61 @@
+# Generated code for FastPix API SDK.
+
+# typed: true
+# frozen_string_literal: true
+
+require 'cgi'
+require 'date'
+require 'base64'
+require 'sorbet-runtime'
+
+module FastpixClient
+  module Utils
+    extend T::Sig
+
+    SERIALIZATION_METHOD_TO_CONTENT_TYPE = {
+        'json': 'application/json',
+        'form': 'application/x-www-form-urlencoded',
+        'multipart': 'multipart/form-data',
+        'raw': 'application/octet-stream',
+        'string': 'text/plain'
+      }.freeze
+  
+    sig do
+      params(request: Object, nullable: T::Boolean, optional: T::Boolean, request_field_name: Symbol, serialization_method: Symbol)
+        .returns([String, Object, T.nilable(T::Array[T::Array[T.any(T::Array[T.nilable(String)], String)]])])
+    end
+    def self.serialize_request_body(request, nullable, optional, request_field_name, serialization_method)
+      return ['', nil, nil] if request.nil? && !nullable && optional
+
+      return serialize_content_type(SERIALIZATION_METHOD_TO_CONTENT_TYPE[serialization_method], request) if !request.respond_to?(:fields) || !request.respond_to?(request_field_name)
+
+      request_val = request.send(request_field_name)
+
+      request_metadata = T.let(nil, T.nilable(T::Array[T::Array[T.any(T::Array[T.nilable(String)], String)]]))
+      T.unsafe(request).fields.each do |f|
+        if f.name == request_field_name
+          request_metadata = f.metadata[:request]
+          break
+        end
+      end
+      raise StandardError, 'invalid request type' if request_metadata.nil?
+
+      serialize_content_type(
+        request_metadata.fetch(:media_type, 'application/octet-stream'), request_val
+      )
+    end
+
+    sig do
+      params(media_type: String, request: Object)
+        .returns([String, Object, T.nilable(T::Array[T::Array[T.any(T::Array[T.nilable(String)], String)]])])
+    end
+    def self.serialize_content_type(media_type, request)
+      return media_type, ::Crystalline.to_json(request), nil if media_type.match('^(application|text)\/([^+]+\+)*json.*')
+      return serialize_multipart_form(media_type, request) if media_type.match('^multipart\/.*')
+      return media_type, serialize_form_data(request), nil if media_type.match('^application\/x-www-form-urlencoded.*')
+      return media_type, request, nil if request.is_a?(String) || request.is_a?(Array)
+
+      raise StandardError, "invalid request body type #{request.class} for mediaType #{media_type}"
+    end
+  end
+end