fastlane_iac_publish 0.1.0

data/spaceship/lib/spaceship/commands_generator.rb

@@ -0,0 +1,52 @@
+require 'highline'
+
+HighLine.track_eof = false
+
+require 'fastlane/version'
+require_relative 'playground'
+require_relative 'spaceauth_runner'
+
+module Spaceship
+  class CommandsGenerator
+    include Commander::Methods
+
+    def self.start
+      self.new.run
+    end
+
+    def run
+      program :name, 'spaceship'
+      program :version, Fastlane::VERSION
+      program :description, Spaceship::DESCRIPTION
+      program :help, 'Author', 'Felix Krause <spaceship@krausefx.com>'
+      program :help, 'Website', 'https://fastlane.tools'
+      program :help, 'GitHub', 'https://github.com/fastlane/fastlane/tree/master/spaceship'
+      program :help_formatter, :compact
+
+      global_option('-u', '--user USERNAME', 'Specify the Apple ID you want to log in with')
+      global_option('--verbose') { FastlaneCore::Globals.verbose = true }
+
+      command :playground do |c|
+        c.syntax = 'fastlane spaceship playground'
+        c.description = 'Run an interactive shell that connects you to Apple web services'
+
+        c.action do |args, options|
+          Spaceship::Playground.new(username: options.user).run
+        end
+      end
+
+      command :spaceauth do |c|
+        c.syntax = 'fastlane spaceship spaceauth'
+        c.description = 'Authentication helper for spaceship/fastlane to work with Apple 2-Step/2FA'
+
+        c.action do |args, options|
+          Spaceship::SpaceauthRunner.new(username: options.user).run
+        end
+      end
+
+      default_command(:playground)
+
+      run!
+    end
+  end
+end

data/spaceship/lib/spaceship/connect_api.rb

@@ -0,0 +1,47 @@
+require 'spaceship/connect_api/model'
+require 'spaceship/connect_api/response'
+require 'spaceship/connect_api/token'
+
+require 'spaceship/connect_api/provisioning/provisioning'
+require 'spaceship/connect_api/testflight/testflight'
+require 'spaceship/connect_api/users/users'
+
+require 'spaceship/connect_api/models/bundle_id_capability'
+require 'spaceship/connect_api/models/bundle_id'
+require 'spaceship/connect_api/models/certificate'
+require 'spaceship/connect_api/models/device'
+require 'spaceship/connect_api/models/profile'
+
+require 'spaceship/connect_api/models/user'
+
+require 'spaceship/connect_api/models/app'
+require 'spaceship/connect_api/models/beta_app_localization'
+require 'spaceship/connect_api/models/beta_build_localization'
+require 'spaceship/connect_api/models/beta_build_metric'
+require 'spaceship/connect_api/models/beta_app_review_detail'
+require 'spaceship/connect_api/models/beta_app_review_submission'
+require 'spaceship/connect_api/models/beta_group'
+require 'spaceship/connect_api/models/beta_tester'
+require 'spaceship/connect_api/models/beta_tester_metric'
+require 'spaceship/connect_api/models/build'
+require 'spaceship/connect_api/models/build_delivery'
+require 'spaceship/connect_api/models/build_beta_detail'
+require 'spaceship/connect_api/models/pre_release_version'
+
+module Spaceship
+  class ConnectAPI
+    extend Spaceship::ConnectAPI::Provisioning
+    extend Spaceship::ConnectAPI::TestFlight
+    extend Spaceship::ConnectAPI::Users
+
+    @token = nil
+
+    class << self
+      attr_writer(:token)
+    end
+
+    class << self
+      attr_reader :token
+    end
+  end
+end

data/spaceship/lib/spaceship/connect_api/client.rb

@@ -0,0 +1,178 @@
+require_relative '../client'
+require_relative './response'
+
+module Spaceship
+  class ConnectAPI
+    class Client < Spaceship::Client
+      attr_accessor :token
+
+      #####################################################
+      # @!group Client Init
+      #####################################################
+
+      # Instantiates a client with cookie session or a JWT token.
+      def initialize(cookie: nil, current_team_id: nil, token: nil)
+        if token.nil?
+          super(cookie: cookie, current_team_id: current_team_id)
+        else
+          options = {
+            request: {
+              timeout:       (ENV["SPACESHIP_TIMEOUT"] || 300).to_i,
+              open_timeout:  (ENV["SPACESHIP_TIMEOUT"] || 300).to_i
+            }
+          }
+          @token = token
+          @current_team_id = current_team_id
+
+          hostname = "https://api.appstoreconnect.apple.com/v1/"
+
+          @client = Faraday.new(hostname, options) do |c|
+            c.response(:json, content_type: /\bjson$/)
+            c.response(:xml, content_type: /\bxml$/)
+            c.response(:plist, content_type: /\bplist$/)
+            c.use(FaradayMiddleware::RelsMiddleware)
+            c.adapter(Faraday.default_adapter)
+            c.headers["Authorization"] = "Bearer #{token.text}"
+
+            if ENV['SPACESHIP_DEBUG']
+              # for debugging only
+              # This enables tracking of networking requests using Charles Web Proxy
+              c.proxy = "https://127.0.0.1:8888"
+              c.ssl[:verify_mode] = OpenSSL::SSL::VERIFY_NONE
+            elsif ENV["SPACESHIP_PROXY"]
+              c.proxy = ENV["SPACESHIP_PROXY"]
+              c.ssl[:verify_mode] = OpenSSL::SSL::VERIFY_NONE if ENV["SPACESHIP_PROXY_SSL_VERIFY_NONE"]
+            end
+
+            if ENV["DEBUG"]
+              puts("To run spaceship through a local proxy, use SPACESHIP_DEBUG")
+            end
+          end
+        end
+      end
+
+      def self.hostname
+        return nil
+      end
+
+      #
+      # Helpers
+      #
+
+      def web_session?
+        return @token.nil?
+      end
+
+      def build_params(filter: nil, includes: nil, limit: nil, sort: nil, cursor: nil)
+        params = {}
+
+        filter = filter.delete_if { |k, v| v.nil? } if filter
+
+        params[:filter] = filter if filter && !filter.empty?
+        params[:include] = includes if includes
+        params[:limit] = limit if limit
+        params[:sort] = sort if sort
+        params[:cursor] = cursor if cursor
+
+        return params
+      end
+
+      def get(url_or_path, params = nil)
+        response = request(:get) do |req|
+          req.url(url_or_path)
+          req.options.params_encoder = Faraday::NestedParamsEncoder
+          req.params = params if params
+          req.headers['Content-Type'] = 'application/json'
+        end
+        handle_response(response)
+      end
+
+      def post(url_or_path, body)
+        response = request(:post) do |req|
+          req.url(url_or_path)
+          req.body = body.to_json
+          req.headers['Content-Type'] = 'application/json'
+        end
+        handle_response(response)
+      end
+
+      def patch(url_or_path, body)
+        response = request(:patch) do |req|
+          req.url(url_or_path)
+          req.body = body.to_json
+          req.headers['Content-Type'] = 'application/json'
+        end
+        handle_response(response)
+      end
+
+      def delete(url_or_path, params = nil, body = nil)
+        response = request(:delete) do |req|
+          req.url(url_or_path)
+          req.options.params_encoder = Faraday::NestedParamsEncoder if params
+          req.params = params if params
+          req.body = body.to_json if body
+          req.headers['Content-Type'] = 'application/json' if body
+        end
+        handle_response(response)
+      end
+
+      protected
+
+      def handle_response(response)
+        if (200...300).cover?(response.status) && (response.body.nil? || response.body.empty?)
+          return
+        end
+
+        raise InternalServerError, "Server error got #{response.status}" if (500...600).cover?(response.status)
+
+        unless response.body.kind_of?(Hash)
+          raise UnexpectedResponse, response.body
+        end
+
+        raise UnexpectedResponse, response.body['error'] if response.body['error']
+
+        raise UnexpectedResponse, handle_errors(response) if response.body['errors']
+
+        raise UnexpectedResponse, "Temporary App Store Connect error: #{response.body}" if response.body['statusCode'] == 'ERROR'
+
+        return Spaceship::ConnectAPI::Response.new(body: response.body, status: response.status, client: self)
+      end
+
+      def handle_errors(response)
+        # Example error format
+        # {
+        #   "errors" : [ {
+        #     "id" : "ce8c391e-f858-411b-a14b-5aa26e0915f2",
+        #     "status" : "400",
+        #     "code" : "PARAMETER_ERROR.INVALID",
+        #     "title" : "A parameter has an invalid value",
+        #     "detail" : "'uploadedDate3' is not a valid field name",
+        #     "source" : {
+        #       "parameter" : "sort"
+        #     }
+        #   } ]
+        # }
+
+        return response.body['errors'].map do |error|
+          "#{error['title']} - #{error['detail']}"
+        end.join(" ")
+      end
+
+      private
+
+      def local_variable_get(binding, name)
+        if binding.respond_to?(:local_variable_get)
+          binding.local_variable_get(name)
+        else
+          binding.eval(name.to_s)
+        end
+      end
+
+      def provider_id
+        return team_id if self.provider.nil?
+        self.provider.provider_id
+      end
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/spaceship/lib/spaceship/connect_api/model.rb

@@ -0,0 +1,152 @@
+module Spaceship
+  class ConnectAPI
+    module Model
+      def self.included(base)
+        Spaceship::ConnectAPI::Models.types ||= []
+        Spaceship::ConnectAPI::Models.types << base
+        base.extend(Spaceship::ConnectAPI::Model)
+      end
+
+      attr_accessor :id
+
+      def initialize(id, attributes)
+        self.id = id
+        update_attributes(attributes)
+      end
+
+      def update_attributes(attributes)
+        attributes.each do |key, value|
+          method = "#{key}=".to_sym
+          self.send(method, value) if self.respond_to?(method)
+        end
+      end
+
+      #
+      # Example:
+      # { "minOsVersion" => "min_os_version" }
+      #
+      # Creates attr_write and attr_reader for :min_os_version
+      # Creates alias for :minOsVersion to :min_os_version
+      #
+      def attr_mapping(attr_map)
+        attr_map.each do |key, value|
+          # Actual
+          reader = value.to_sym
+          writer = "#{value}=".to_sym
+
+          has_reader = instance_methods.include?(reader)
+          has_writer = instance_methods.include?(writer)
+
+          send(:attr_reader, value) unless has_reader
+          send(:attr_writer, value) unless has_writer
+
+          # Alias
+          key_reader = key.to_sym
+          key_writer = "#{key}=".to_sym
+
+          # Alias the API response name to attribute name
+          alias_method(key_reader, reader)
+          alias_method(key_writer, writer)
+        end
+      end
+    end
+
+    module Models
+      class << self
+        attr_accessor :types
+        attr_accessor :types_cache
+      end
+
+      def self.parse(json)
+        data = json["data"]
+        raise "No data" unless data
+
+        included = json["included"] || []
+
+        if data.kind_of?(Hash)
+          inflate_model(data, included)
+        elsif data.kind_of?(Array)
+          return data.map do |model_data|
+            inflate_model(model_data, included)
+          end
+        else
+          raise "'data' is neither a hash nor an array"
+        end
+      end
+
+      def self.find_class(model_data)
+        # Initialize cache
+        @types_cache ||= {}
+
+        # Find class in cache
+        type_string = model_data["type"]
+        type_class = @types_cache[type_string]
+        return type_class if type_class
+
+        # Find class in array
+        type_class = @types.find do |type|
+          type.type == type_string
+        end
+
+        # Cache and return class
+        @types_cache[type_string] = type_class
+        return type_class
+      end
+
+      def self.inflate_model(model_data, included)
+        # Find class
+        type_class = find_class(model_data)
+        raise "No type class found for #{model_data['type']}" unless type_class
+
+        # Get id and attributes needed for inflating
+        id = model_data["id"]
+        attributes = model_data["attributes"]
+
+        # Instantiate object and inflate relationships
+        relationships = model_data["relationships"] || []
+        type_instance = type_class.new(id, attributes)
+        type_instance = inflate_model_relationships(type_instance, relationships, included)
+
+        return type_instance
+      end
+
+      def self.inflate_model_relationships(type_instance, relationships, included)
+        # Relationship attributes to set
+        attributes = {}
+
+        # 1. Iterate over relationships
+        # 2. Find id and type
+        # 3. Find matching id and type in included
+        # 4. Inflate matching data and set in attributes
+        relationships.each do |key, value|
+          # Validate data exists
+          value_data_or_datas = value["data"]
+          next unless value_data_or_datas
+
+          # Map an included data object
+          map_data = lambda do |value_data|
+            id = value_data["id"]
+            type = value_data["type"]
+
+            relationship_data = included.find do |included_data|
+              id == included_data["id"] && type == included_data["type"]
+            end
+
+            inflate_model(relationship_data, included)
+          end
+
+          # Map a hash or an array of data
+          if value_data_or_datas.kind_of?(Hash)
+            attributes[key] = map_data.call(value_data_or_datas)
+          elsif value_data_or_datas.kind_of?(Array)
+            attributes[key] = value_data_or_datas.map(&map_data)
+          end
+        end
+
+        type_instance.update_attributes(attributes)
+
+        return type_instance
+      end
+    end
+  end
+end

data/spaceship/lib/spaceship/connect_api/models/app.rb

@@ -0,0 +1,97 @@
+require_relative '../model'
+require_relative './build'
+
+module Spaceship
+  class ConnectAPI
+    class App
+      include Spaceship::ConnectAPI::Model
+
+      attr_accessor :name
+      attr_accessor :bundle_id
+      attr_accessor :sku
+      attr_accessor :primary_locale
+      attr_accessor :removed
+      attr_accessor :is_aag
+
+      self.attr_mapping({
+        "name" => "name",
+        "bundleId" => "bundle_id",
+        "sku" => "sku",
+        "primaryLocale" => "primary_locale",
+        "removed" => "removed",
+        "isAAG" => "is_aag"
+      })
+
+      def self.type
+        return "apps"
+      end
+
+      #
+      # Apps
+      #
+
+      def self.all(filter: {}, includes: nil, limit: nil, sort: nil)
+        resps = Spaceship::ConnectAPI.get_apps(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
+        return resps.map(&:to_models).flatten
+      end
+
+      def self.find(bundle_id)
+        return all(filter: { bundleId: bundle_id }).find do |app|
+          app.bundle_id == bundle_id
+        end
+      end
+
+      def self.get(app_id: nil, includes: nil)
+        return Spaceship::ConnectAPI.get_app(app_id: app_id, includes: includes).first
+      end
+
+      #
+      # Beta Testers
+      #
+
+      def get_beta_testers(filter: {}, includes: nil, limit: nil, sort: nil)
+        filter ||= {}
+        filter[:apps] = id
+
+        resps = Spaceship::ConnectAPI.get_beta_testers(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
+        return resps.map(&:to_models).flatten
+      end
+
+      #
+      # Builds
+      #
+
+      def get_builds(filter: {}, includes: nil, limit: nil, sort: nil)
+        filter ||= {}
+        filter[:app] = id
+
+        resps = Spaceship::ConnectAPI.get_builds(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
+        return resps.map(&:to_models).flatten
+      end
+
+      def get_build_deliveries(filter: {}, includes: nil, limit: nil, sort: nil)
+        filter ||= {}
+        filter[:app] = id
+
+        resps = Spaceship::ConnectAPI.get_build_deliveries(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
+        return resps.map(&:to_models).flatten
+      end
+
+      def get_beta_app_localizations(filter: {}, includes: nil, limit: nil, sort: nil)
+        filter ||= {}
+        filter[:app] = id
+
+        resps = Spaceship::ConnectAPI.get_beta_app_localizations(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
+        return resps.map(&:to_models).flatten
+      end
+
+      def get_beta_groups(filter: {}, includes: nil, limit: nil, sort: nil)
+        filter ||= {}
+        filter[:app] = id
+
+        resps = Spaceship::ConnectAPI.get_beta_groups(filter: filter, includes: includes, limit: limit, sort: sort).all_pages
+        return resps.map(&:to_models).flatten
+      end
+    end
+  end
+end