fastlane-plugin-react_native_release 0.6.0 → 0.7.0

data/lib/fastlane/plugin/react_native_release/actions/encrypt_fastlane_vars.rb

@@ -0,0 +1,61 @@
+require 'fastlane/action'
+require 'fastlane/plugin/cryptex'
+
+module Fastlane
+  module Actions
+    class EncryptFastlaneVarsAction < Action
+      ANDROID_ENV_PATH = "./android/fastlane/.env"
+      IOS_ENV_PATH = './ios/fastlane/.env'
+      FASTLANE_CRYPTEX_KEY = 'fastlane_vars'
+
+      def self.run(params)
+        if !File.exists?(IOS_ENV_PATH)
+          UI.user_error!("No .env found in ios directory!")
+        end
+
+        if !File.exists?(ANDROID_ENV_PATH)
+          UI.user_error!("No .env found in Android directory")
+        end
+
+        if !UI.confirm("This will save values from your #{IOS_ENV_PATH} and #{ANDROID_ENV_PATH} to the encrypted context repo. Proceed?")
+          UI.abort_with_message!("Stepping away...")
+        end
+
+        android_env_vars = Dotenv.parse(ANDROID_ENV_PATH)
+        ios_env_vars = Dotenv.parse(IOS_ENV_PATH)
+        vars = android_env_vars.merge(ios_env_vars)
+    
+        other_action.cryptex(
+          type: "import_env",
+          key: FASTLANE_CRYPTEX_KEY,
+          hash: vars,
+        )
+
+        UI.success "ENV vars set in context repo."
+      end
+
+      def self.description
+        "Encrypt fastlane vars for CI"
+      end
+
+      def self.authors
+        ["cball", "isaiahgrey93"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        "Saves the current vars in android/fastlane/.env and ios/fastlane/.env"
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        [:ios, :android].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/react_native_release/actions/encrypt_google_play_credentials.rb

@@ -0,0 +1,64 @@
+require 'fastlane/action'
+require 'fastlane/plugin/cryptex'
+
+module Fastlane
+  module Actions
+    class EncryptGooglePlayCredentialsAction < Action
+      def self.run(params)
+        key = Helper::ReactNativeReleaseHelper::GOOGLE_PLAY_CREDENTIALS_CRYPTEX_KEY
+        json_path = params[:json_path]
+
+        begin
+          other_action.cryptex(
+            type: "import",
+            key: key,
+            in: json_path
+          )
+        rescue => ex
+          UI.abort_with_message!('Error encrypting Google Play Credentials.')
+        end
+
+        UI.success("Encrypted #{json_path} as #{key}")
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Encrypts credentials from Google Play and stores in the context repo."
+      end
+
+      def self.details
+        # Optional:
+        # this is your chance to provide a more detailed description of this action
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :json_path,
+                                       env_name: "FL_ENCRYPT_GOOGLE_PLAY_CREDENTIALS_JSON_PATH",
+                                       description: "Enter path to the json you downloaded from Google, or drop the file here",
+                                       type: String)
+        ]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # "Saves the current vars in android/fastlane/.env and ios/fastlane/.env"
+      end
+
+      def self.authors
+        # So no one will ever forget your contribution to fastlane :) You are awesome btw!
+        ["cball", "isaiahgrey93"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/react_native_release/actions/generate_android_keystore.rb

@@ -0,0 +1,137 @@
+require 'fastlane/action'
+require 'fastlane/plugin/cryptex'
+
+module Fastlane
+  module Actions
+    class GenerateAndroidKeystoreAction < Action
+      def self.run(params)
+        encrypt_in_repo = params[:encrypt_in_repo]
+        key = Helper::ReactNativeReleaseHelper::ANDROID_KEYSTORE_CRYPTEX_KEY
+
+        # Confirm if there is an existing key in the repo... we don't want to overwrite prod!
+        begin
+          existing_remote_key = other_action.cryptex(
+            type: "export",
+            key: key
+          )
+        # If we don't have a keystore, cryptex will throw an exception.
+        rescue => ex
+          # create a new keystore and encrypt it
+          UI.message('no keystore found in repo. creating it.')
+          keystore = create_keystore_with_params(params)
+          message = 'Created keystore'
+
+          if encrypt_in_repo
+            encrypt_keystore(keystore)
+            message.concat(' and saved to repo.')
+          end
+
+          UI.success(message)
+        end
+
+        # If encrypting, confirm remote overwrite
+        if (encrypt_in_repo && UI.confirm("This will overwrite your existing keystore! Are you sure?"))
+          keystore_path = create_keystore_with_params(params)
+          encrypt_keystore(keystore_path)
+          UI.success('Created keystore and saved to repo.')
+        elsif encrypt_in_repo
+          # The user does not want to proceed
+          UI.abort_with_message!("Stepping away...")
+        else
+          # Create, but don't encrypt
+          create_keystore_with_params(params)
+
+          UI.success('Created keystore, but did not save it to the repo.')
+        end
+      end
+
+      # Creates a new android keystore based on the provided params. Wraps Cryptex.
+      def self.create_keystore_with_params(params)
+        begin
+          other_action.cryptex_generate_keystore(
+            destination: params[:destination],
+            password: params[:password],
+            fullname: params[:fullname],
+            city: params[:city],
+            alias: params[:alias]
+          )
+        rescue => ex
+          UI.abort_with_message!("Could not create keystore. Do you already have one with this alias?")
+        end
+
+        params[:destination]
+      end
+
+      # Saves a keystore to the repo. Note this will overwrite it!
+      def self.encrypt_keystore(keystore_path)
+        key = Helper::ReactNativeReleaseHelper::ANDROID_KEYSTORE_CRYPTEX_KEY
+
+        other_action.cryptex(
+          type: "import",
+          in: keystore_path,
+          key: key
+        )
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Decrypts app env vars and sets the values in the root .env file"
+      end
+
+      def self.details
+        # Optional:
+        # this is your chance to provide a more detailed description of this action
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :encrypt_in_repo,
+                                       env_name: "FL_GENERATE_ANDROID_KEYSTORE_ENCRYPT_IN_REPO",
+                                       description: "If the new keystore should be encrypted and saved",
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :password,
+                                       env_name: "FL_GENERATE_ANDROID_KEYSTORE_PASSWORD",
+                                       description: "Password for the Keystore",
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :alias,
+                                       env_name: "FL_GENERATE_ANDROID_KEYSTORE_ALIAS",
+                                       description: "ALIAS for the Keystore",
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :destination,
+                                       env_name: "FL_GENERATE_ANDROID_KEYSTORE_DESTINATION",
+                                       description: "Where to put decrypted keystore",
+                                       default_value: Helper::ReactNativeReleaseHelper::ANDROID_KEYSTORE_PATH),
+          FastlaneCore::ConfigItem.new(key: :fullname,
+                                       env_name: "FL_GENERATE_ANDROID_KEYSTORE_FULLNAME",
+                                       description: "Fullname of keystore owner",
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :city,
+                                       env_name: "FL_GENERATE_ANDROID_KEYSTORE_CITY",
+                                       description: "City of keystore owner",
+                                       type: String),
+        ]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        # "Saves the current vars in android/fastlane/.env and ios/fastlane/.env"
+      end
+
+      def self.authors
+        # So no one will ever forget your contribution to fastlane :) You are awesome btw!
+        ["cball", "isaiahgrey93"]
+      end
+
+      def self.is_supported?(platform)
+        [:ios, :android].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/react_native_release/actions/{react_native_release_action.rb → react_native_release.rb}

@@ -4,45 +4,39 @@ require_relative '../helper/react_native_release_helper'
 module Fastlane
   module Actions
     class ReactNativeReleaseAction < Action
-      VALID_TARGETS = %w{beta production}
+      VALID_RELEASE_TYPES = %w{beta release hotfix}
 
+      # params:
+      # release_type, alpha_branch, beta_branch, release_branch, hotfix_destination
       def self.run(params)
         require 'fastlane/plugin/android_versioning'
-
         other_action.create_fastlane_session
 
-        target = UI.select "Select a release type:", VALID_TARGETS
-        is_beta = target.include?('beta')
-        is_hotfix = params[:hotfix] === true
+        release_type = params[:release_type] || UI.select("Select a release type:", VALID_RELEASE_TYPES)
+        is_beta = release_type.include?('beta')
+        is_release = release_type.include?('release')
+        is_hotfix = release_type.include?('hotfix')
+
         ios_version = other_action.get_version_number(xcodeproj: params[:xcodeproj], target: File.basename(params[:xcodeproj], '.*'))
         android_version = other_action.get_version_name(app_project_dir: params[:android_app_dir])
         should_prompt_for_version_bump = params[:prompt_for_version_bump] === true || is_beta
 
         if is_beta
-          tag_prefix = 'betas'
-          base_branch = params[:alpha_branch]
-          target_branch = params[:beta_branch]
-        else
-          tag_prefix = 'releases'
-          base_branch = params[:beta_branch]
-          target_branch = params[:production_branch]
+          # TODO: ohter branches
+          verify_git_branch_state(beta_branch)
         end
 
-        # Ensure we're on the right branch and in a good state
-        other_action.ensure_git_branch(branch: base_branch)
-        other_action.ensure_git_status_clean
-        sh "git branch --set-upstream-to=origin/#{base_branch} #{base_branch}"
-        other_action.git_pull
+        # TODO: flows
 
         # Cut a fresh branch unless this is a hotfix
-        if !is_hotfix
-          # delete an existing branch if we have one
-          sh "git show-ref #{target_branch}" do |status|
-            sh "git branch -D #{target_branch}" if status.success?
-          end
+        # if !is_hotfix
+        #   # delete an existing branch if we have one
+        #   sh "git show-ref #{target_branch}" do |status|
+        #     sh "git branch -D #{target_branch}" if status.success?
+        #   end
           
-          sh "git checkout -b #{target_branch}"
-        end
+        #   sh "git checkout -b #{target_branch}"
+        # end
 
         # Tag / Bump version
         if should_prompt_for_version_bump
@@ -61,13 +55,13 @@ module Fastlane
           end
         end
 
-        # Tag it
-        tag_name = "#{tag_prefix}/ios-#{ios_version}-android-#{android_version}"
+        # Tag it. TODO: release
+        tag_name = "release/ios-#{ios_version}-android-#{android_version}"
         other_action.add_git_tag(tag: tag_name)
-        other_action.push_to_git_remote(
-          local_branch: target_branch,
-          force: true
-        )
+        # other_action.push_to_git_remote(
+        #   local_branch: target_branch,
+        #   force: true
+        # )
 
         merge_branch(branch: target_branch, target: base_branch)
         return if is_beta
@@ -83,7 +77,7 @@ module Fastlane
         target = options[:target]
       
         sh "git checkout #{target}"
-        sh "git merge origin/#{branch} --no-ff -m 'Merge #{branch} -> #{target} [skip ci]' " do |status|
+        sh "git merge origin/#{branch} --no-ff -m 'chore(release): Merge #{branch} -> #{target} [skip ci]' " do |status|
           unless status.success?
             UI.error "Failed to merge #{branch} into #{target}"
           end
@@ -116,6 +110,14 @@ module Fastlane
           bump_type: version_bump
         )
       end
+
+      def self.verify_git_branch_state(branch)
+        # Ensure we're on the right branch and in a good state
+        # other_action.ensure_git_branch(branch)
+        other_action.ensure_git_status_clean
+        sh "git branch --set-upstream-to=origin/#{branch} #{branch}"
+        other_action.git_pull
+      end
       
       def self.prompt_for_version
         UI.select("Update Version?: ", ["none", "major", "minor", "patch"])

data/lib/fastlane/plugin/react_native_release/actions/read_fastlane_session.rb

@@ -0,0 +1,55 @@
+require 'fastlane/action'
+require 'fastlane/plugin/cryptex'
+
+module Fastlane
+  module Actions
+    class ReadFastlaneSessionAction < Action
+      def self.run(params)
+        key = Helper::ReactNativeReleaseHelper::FASTLANE_SESSION_CRYPTEX_KEY
+        fastlane_session_git_url =  ENV["CRYPTEX_GIT_URL"]
+        fastlane_session_password = ENV["CRYPTEX_PASSWORD"]
+        fastlane_session_cookie_path = Tempfile.new('')
+
+        UI.message "Reading fastlane session.."
+
+        other_action.cryptex(
+          type: "export",
+          out: fastlane_session_cookie_path.path,
+          key: key,
+        )
+
+        fastlane_session = (open fastlane_session_cookie_path.path).read
+
+        UI.message fastlane_session_cookie_path.path
+        UI.message fastlane_session
+
+        ENV["FASTLANE_SESSION"] = fastlane_session
+
+        UI.success "Read FASTLANE_SESSION from remote repository."
+      end
+
+      def self.description
+        "Simplify 2FA authentication for App Store Connect"
+      end
+
+      def self.authors
+        ["cball", "isaiahgrey93"]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        "Fetches an encrypted cookie for authenticating with App Store connecting. Handles fetching and decrypting the cookie before setting to the local env."
+      end
+
+      def self.is_supported?(platform)
+        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
+        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
+        #
+        [:ios, :android].include?(platform)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/react_native_release/helper/react_native_release_helper.rb

@@ -5,11 +5,20 @@ module Fastlane
 
   module Helper
     class ReactNativeReleaseHelper
-      # class methods that you define here become available in your action
-      # as `Helper::ReactNativeReleaseHelper.your_method`
-      #
-      def self.show_message
-        UI.message("Hello from the react_native_release plugin helper!")
+      FASTLANE_CRYPTEX_KEY = 'fastlane_vars'
+      APP_CRYPTEX_KEY = 'app_vars'
+      APP_ENV_PATH = '.env'
+      VALID_NAMESPACES = ['alpha', 'beta', 'release', ''] # empty string denotes root namespace
+      ANDROID_KEYSTORE_CRYPTEX_KEY = 'ANDROID_KEYSTORE'
+      ANDROID_KEYSTORE_PATH = "../app/android.keystore"
+      GOOGLE_PLAY_CREDENTIALS_CRYPTEX_KEY = 'GOOGLE_PLAY_CREDS'
+      FASTLANE_SESSION_CRYPTEX_KEY = 'FASTLANE_SESSION'
+
+      # returns an app key for a specific namespace. Ex: beta_app_vars
+      def self.app_key_for(namespace)
+        return APP_CRYPTEX_KEY if namespace.strip.empty?
+
+        "#{namespace}_#{APP_CRYPTEX_KEY}"
       end
     end
   end