Asc Release Flow

Asc Release Flow is a community skill for managing App Store release workflows through the App Store Connect API, covering version creation, submission preparation, review management, phased release configuration, and automated release pipeline orchestration.

What Is This?

Overview

Asc Release Flow provides patterns for automating the App Store submission and release process. It covers version creation that initializes new app versions with metadata and build assignments, submission preparation that validates required fields, screenshots, and compliance information before submitting for review, review management that tracks submission status and handles reviewer rejections with resubmission, phased release configuration that sets up gradual rollout percentages over a 7-day period, and pipeline orchestration that connects CI builds to App Store submission workflows. The skill enables iOS teams to automate releases from build to App Store availability.

Who Should Use This

This skill serves release managers automating App Store submissions and tracking review status, iOS engineers building CI/CD pipelines that include App Store deployment, and product teams managing phased releases with rollback capabilities.

Why Use It?

Problems It Solves

Manual submissions through the dashboard require clicking through multiple screens for each release. Missing metadata or screenshots cause submission rejections discovered only after waiting for review. Phased release management requires daily monitoring and manual percentage updates. Review rejections need timely response and resubmission that is easy to delay.

Core Highlights

Version manager creates and configures new app versions through the API. Submission validator checks all required fields before submitting for review. Review tracker monitors submission status and alerts on state changes. Phased release controller manages rollout percentages and pause or resume operations.

How to Use It?

Basic Usage

// Release flow manager
import Foundation

struct ReleaseManager {
  let api: ASCClient

  func createVersion(
    appId: String,
    versionString: String,
    platform: String
      = "IOS"
  ) async throws -> String {
    let resp =
      try await api.post(
        path:
          "/v1/appStoreVersions",
        body: [
          "data": [
            "type":
              "appStoreVersions",
            "attributes": [
              "versionString":
                versionString,
              "platform":
                platform,
              "releaseType":
                "MANUAL",
            ],
            "relationships": [
              "app": [
                "data": [
                  "type":
                    "apps",
                  "id": appId,
                ]
              ]
            ]
          ]
        ])
    return resp.data.id
  }

  func submitForReview(
    versionId: String
  ) async throws {
    try await api.post(
      path:
        "/v1/appStoreVersion"
        + "Submissions",
      body: [
        "data": [
          "type":
            "appStoreVersion"
            + "Submissions",
          "relationships": [
            "appStoreVersion":
              ["data": [
                "type":
                  "appStore"
                  + "Versions",
                "id":
                  versionId]]
          ]
        ]
      ])
  }
}

Real-World Examples

// Phased release controller
struct PhasedRelease {
  let api: ASCClient

  func enablePhasedRelease(
    versionId: String
  ) async throws {
    try await api.post(
      path:
        "/v1/appStoreVersion"
        + "PhasedReleases",
      body: [
        "data": [
          "type":
            "appStoreVersion"
            + "PhasedReleases",
          "attributes": [
            "phasedReleaseState":
              "ACTIVE"],
          "relationships": [
            "appStoreVersion":
              ["data": [
                "type":
                  "appStore"
                  + "Versions",
                "id":
                  versionId]]
          ]
        ]
      ])
  }

  func pauseRelease(
    phasedReleaseId: String
  ) async throws {
    try await api.patch(
      path:
        "/v1/appStoreVersion"
        + "PhasedReleases/"
        + phasedReleaseId,
      body: [
        "data": [
          "type":
            "appStoreVersion"
            + "PhasedReleases",
          "id":
            phasedReleaseId,
          "attributes": [
            "phasedReleaseState":
              "PAUSE"]
        ]
      ])
  }
}

Advanced Tips

Implement pre-submission validation that checks all required metadata, screenshots, and build assignment before attempting submission. Monitor crash rates during phased release and automatically pause rollout when crash thresholds are exceeded. Set up webhooks to notify the team on review status changes.

When to Use It?

Use Cases

Automate the full release flow from version creation through App Store review submission. Configure phased release with automatic pause on crash rate spikes. Build a CI pipeline that submits builds for review after TestFlight validation.

Related Topics

App Store Connect API, release management, phased release, app review, and CI/CD deployment.

Important Notes

Requirements

App Store Connect API key with App Manager or Admin role permissions. Completed app metadata and screenshots for the version being submitted. Valid build assigned to the version for review.

Usage Recommendations

Do: validate all submission requirements locally before calling the submit API. Use phased release for major updates to catch issues with a small user percentage. Track review times to plan release schedules around typical review duration.

Don't: submit for review without verifying metadata completeness as partial submissions are rejected. Ignore review rejection notes which must be addressed before resubmission. Release to 100 percent immediately after approval without monitoring crash metrics.

Limitations

App Review times are unpredictable and cannot be shortened through the API. Phased release only controls automatic update distribution and does not prevent manual user updates. Rejected submissions require manual review of rejection reasons before automated resubmission.