Asc Id Resolver

Asc Id Resolver is a community skill for resolving and mapping identifiers across App Store Connect entities, covering app ID lookups, bundle ID resolution, version and build ID mapping, team and user ID discovery, and cross-reference utilities for App Store Connect automation.

What Is This?

Overview

Asc Id Resolver provides patterns for looking up and mapping the various identifiers used across App Store Connect. It covers app ID lookups that resolve human-readable app names and bundle IDs to API resource identifiers, bundle ID resolution that maps registered identifiers to capability configurations, version and build ID mapping that translates version strings and build numbers to resource IDs, team and user ID discovery that resolves member names to API identifiers, and cross-reference utilities for lookup tables between names and IDs. The skill enables scripts and tools to work with readable identifiers instead of opaque API IDs.

Who Should Use This

This skill serves iOS automation engineers building tools that reference App Store Connect resources by name, CI pipeline developers resolving app and build IDs dynamically during deployment, and release managers scripting operations across multiple apps and versions.

Why Use It?

Problems It Solves

App Store Connect API operations require opaque resource IDs that are not human-readable. Scripts hardcoding resource IDs break when IDs change across environments. Looking up the correct ID for a specific app version or build requires multiple API calls. Team member management by name instead of ID needs resolution logic.

Core Highlights

App resolver maps bundle IDs and names to API resource identifiers. Build resolver translates version and build number pairs to build resource IDs. User resolver looks up team members by email to get their API identifiers. Cache layer stores resolved IDs to minimize repeated API lookups.

How to Use It?

Basic Usage

// ID resolver for ASC
import Foundation

struct ASCIdResolver {
  let api: ASCClient
  private var cache:
    [String: String] = [:]

  mutating func resolveApp(
    bundleId: String
  ) async throws -> String {
    let key =
      "app:\(bundleId)"
    if let cached =
        cache[key] {
      return cached
    }

    let apps =
      try await api.get(
        path: "/v1/apps",
        query: [
          "filter[bundleId]":
            bundleId])

    guard let app =
        apps.data.first
    else {
      throw ResolverError
        .notFound(
          "App \(bundleId)")
    }
    cache[key] = app.id
    return app.id
  }

  mutating func resolveBuild(
    appId: String,
    version: String,
    buildNumber: String
  ) async throws -> String {
    let key = "build:"
      + "\(appId):"
      + "\(version):"
      + "\(buildNumber)"
    if let cached =
        cache[key] {
      return cached
    }

    let builds =
      try await api.get(
        path: "/v1/builds",
        query: [
          "filter[app]":
            appId,
          "filter[version]":
            version])

    guard let build =
        builds.data.first(
          where: {
            $0.attributes
              .version
            == buildNumber })
    else {
      throw ResolverError
        .notFound(
          "Build \(version)"
          + "(\(buildNumber))")
    }
    cache[key] = build.id
    return build.id
  }
}

Real-World Examples

// Cross-reference resolver
struct CrossRefResolver {
  var appResolver:
    ASCIdResolver

  func resolveVersion(
    bundleId: String,
    versionString: String
  ) async throws
      -> VersionInfo {
    let appId =
      try await appResolver
        .resolveApp(
          bundleId: bundleId)

    let versions =
      try await appResolver
        .api.get(
          path: "/v1/apps/"
          + "\(appId)/"
          + "appStoreVersions",
          query: [
            "filter[version"
            + "String]":
              versionString])

    guard let version =
        versions.data.first
    else {
      throw ResolverError
        .notFound(
          "Version "
          + versionString)
    }

    return VersionInfo(
      appId: appId,
      versionId: version.id,
      state: version
        .attributes.state,
      versionString:
        versionString)
  }
}

Advanced Tips

Cache resolved IDs in a local file or database for long-running automation that makes repeated lookups. Implement bulk resolution that fetches multiple apps in a single API call using filter parameters. Add fallback resolution that tries alternative identifiers when the primary lookup returns no results.

When to Use It?

Use Cases

Resolve a bundle ID to its App Store Connect app ID for use in build management scripts. Map a version string and build number to the API build resource ID for TestFlight distribution. Look up team member IDs by email for automated role assignment.

Related Topics

App Store Connect API, identifier resolution, iOS automation, build management, and API integration.

Important Notes

Requirements

App Store Connect API key with read access to apps and builds. API client configured with JWT authentication. Knowledge of target bundle IDs or app names for resolution.

Usage Recommendations

Do: cache resolved IDs to minimize API calls in automation scripts. Handle not-found cases gracefully with clear error messages. Validate resolved IDs by confirming the returned resource matches expectations.

Don't: hardcode API resource IDs in scripts as they may change across environments. Cache IDs indefinitely without expiration as resources can be deleted or recreated. Make resolution calls in tight loops without caching which exhausts API rate limits.

Limitations

ID resolution requires active API access and fails when the API is unreachable. Deleted apps and builds cannot be resolved as they no longer appear in API responses. Rate limits throttle bulk resolution across many apps.