Version Management Strategies

1
class FanvueAPIClient {
2
  constructor(apiKey, version) {
3
    this.apiKey = apiKey;
4
    this.version = version;
5
    this.baseURL = "https://api.fanvue.com";
6
  }
7
8
  async request(endpoint, options = {}) {
9
    const response = await fetch(`${this.baseURL}${endpoint}`, {
10
      ...options,
11
      headers: {
12
        "X-Fanvue-API-Key": this.apiKey,
13
        "X-Fanvue-API-Version": this.version,
14
        "Content-Type": "application/json",
15
        ...options.headers,
16
      },
17
    });
18
19
    // Check for deprecation warnings
20
    this.handleDeprecationHeaders(response);
21
22
    return this.handleResponse(response);
23
  }
24
25
  handleDeprecationHeaders(response) {
26
    const deprecation = response.headers.get("Deprecation");
27
    const sunset = response.headers.get("Sunset");
28
    const nextVersion = response.headers.get("X-Fanvue-API-Next-Version");
29
30
    if (deprecation) {
31
      console.warn(`API version ${this.version} is deprecated as of ${deprecation}`);
32
      if (sunset) {
33
        console.warn(`Version will stop working on ${sunset}`);
34
      }
35
      if (nextVersion) {
36
        console.warn(`Consider upgrading to version ${nextVersion}`);
37
      }
38
    }
39
  }
40
}

1
async function handleResponse(response) {
2
  if (response.status === 400) {
3
    const error = await response.json();
4
    if (error.error === "Unsupported API version") {
5
      throw new UnsupportedVersionError(error.message);
6
    }
7
  }
8
9
  if (response.status === 410) {
10
    const error = await response.json();
11
    if (error.error === "API version no longer supported") {
12
      throw new SunsetVersionError(error.message, error.nextVersion);
13
    }
14
  }
15
16
  if (!response.ok) {
17
    throw new APIError(`HTTP ${response.status}: ${response.statusText}`);
18
  }
19
20
  return response.json();
21
}
22
23
class UnsupportedVersionError extends Error {
24
  constructor(message) {
25
    super(message);
26
    this.name = "UnsupportedVersionError";
27
  }
28
}
29
30
class SunsetVersionError extends Error {
31
  constructor(message, nextVersion) {
32
    super(message);
33
    this.name = "SunsetVersionError";
34
    this.nextVersion = nextVersion;
35
  }
36
}

1
// Good: Explicit version pinning
2
const client = new FanvueAPIClient(apiKey, "2025-06-26");
3
4
// Avoid: Dynamic version selection in production
5
const client = new FanvueAPIClient(apiKey, getLatestVersion());

1
class VersionMigrationClient extends FanvueAPIClient {
2
  constructor(apiKey, primaryVersion, fallbackVersion) {
3
    super(apiKey, primaryVersion);
4
    this.fallbackVersion = fallbackVersion;
5
  }
6
7
  async requestWithFallback(endpoint, options = {}) {
8
    try {
9
      return await this.request(endpoint, options);
10
    } catch (error) {
11
      if (error instanceof SunsetVersionError) {
12
        console.warn(`Primary version sunset, falling back to ${this.fallbackVersion}`);
13
        // Create temporary client with fallback version
14
        const fallbackClient = new FanvueAPIClient(this.apiKey, this.fallbackVersion);
15
        return await fallbackClient.request(endpoint, options);
16
      }
17
      throw error;
18
    }
19
  }
20
}

1
class MonitoredAPIClient extends FanvueAPIClient {
2
  constructor(apiKey, version, metricsCollector) {
3
    super(apiKey, version);
4
    this.metrics = metricsCollector;
5
  }
6
7
  handleDeprecationHeaders(response) {
8
    const deprecation = response.headers.get("Deprecation");
9
    const sunset = response.headers.get("Sunset");
10
11
    if (deprecation) {
12
      this.metrics.increment("api.version.deprecated", {
13
        version: this.version,
14
        deprecation_date: deprecation,
15
        sunset_date: sunset,
16
      });
17
18
      // Alert if sunset is approaching
19
      if (sunset) {
20
        const sunsetDate = new Date(sunset);
21
        const daysUntilSunset = (sunsetDate - new Date()) / (1000 * 60 * 60 * 24);
22
23
        if (daysUntilSunset <= 30) {
24
          this.metrics.alert("api.version.sunset_approaching", {
25
            version: this.version,
26
            days_remaining: Math.floor(daysUntilSunset),
27
          });
28
        }
29
      }
30
    }
31
  }
32
}