@heroku/sdk 0.11.2 → 0.12.1

package/dist/resources/data/database-credential/rotate.js

@@ -0,0 +1,71 @@
+import { withSignal } from '../../../core/with-signal.js';
+import { resolveAddonInternal } from '../../platform/add-on/resolve.js';
+import { getPostgresServiceName, isAdvancedDatabase, isEssentialDatabase, isLegacyEssentialDatabase, } from '../internal/postgres-utils.js';
+export async function rotate(ctx, addonIdentity, body = {}, options = {}) {
+    const { appIdentity, beforeRotate, signal } = options;
+    signal?.throwIfAborted();
+    // Bind the signal so the resolve and rotate requests abort in flight.
+    const platform = withSignal(ctx.platform, signal);
+    const addon = await resolveAddonInternal(platform, addonIdentity, {
+        addonService: getPostgresServiceName(), appIdentity,
+    });
+    const { all, credName, forced } = body;
+    const isAdvancedTier = isAdvancedDatabase(addon);
+    // Check for essential tier only; legacy Essential-tier databases
+    // get their own message below and are otherwise treated like
+    // any other classic-tier database for credential selection.
+    const isEssentialTier = isEssentialDatabase(addon);
+    if (!isAdvancedTier && credName && credName !== 'default') {
+        if (isLegacyEssentialDatabase(addon)) {
+            throw new Error('Legacy Essential-tier databases do not support named credentials.');
+        }
+        if (isEssentialTier) {
+            throw new Error('Essential-tier databases do not support named credentials.');
+        }
+    }
+    const data = withSignal(ctx.data, signal);
+    const attachments = await platform.addOnAttachment.listByAddOn(addon.id);
+    let ownerCred;
+    let defaultCred;
+    let credToRotate;
+    if (isAdvancedTier) {
+        const { items: availableCreds } = await data.postgresCredential.list(addon.id);
+        ownerCred = availableCreds.find(cred => cred.type === 'owner');
+        credToRotate = credName
+            ? availableCreds.find(cred => cred.name === credName)
+            : ownerCred;
+    }
+    else {
+        const availableCreds = await data.postgresDatabase.listCredentials(addon.id);
+        defaultCred = isEssentialTier
+            ? availableCreds[0]
+            : availableCreds.find(cred => cred.name === 'default');
+        credToRotate = credName && !isEssentialTier
+            ? availableCreds.find(cred => cred.name === credName)
+            : defaultCred;
+    }
+    await beforeRotate?.({
+        addon,
+        attachments,
+        credToRotate,
+        defaultCred,
+        isAdvancedTier,
+        isEssentialTier,
+        ownerCred,
+    });
+    signal?.throwIfAborted();
+    if (all) {
+        const credentials = await (isAdvancedTier
+            ? data.postgres.rotateCredentials(addon.id, { forced })
+            : data.postgresDatabase.rotateCredentials(addon.id, { forced }));
+        return { addon, credentials };
+    }
+    const finalCredName = isEssentialTier ? 'default' : credToRotate?.name;
+    if (!finalCredName) {
+        throw new Error(`There are no credentials on the database ${addon.name}.`);
+    }
+    const credential = await (isAdvancedTier
+        ? data.postgresCredential.rotate(addon.id, finalCredName, { forced })
+        : data.postgresDatabase.rotateCredential(addon.id, finalCredName, { forced }));
+    return { addon, credential };
+}

package/dist/resources/data/internal/parse-attachment-factors.d.ts

@@ -0,0 +1,25 @@
+declare enum AttachmentFactorKeys {
+    POOL = "pool",
+    PROXY = "proxy",
+    ROLE = "role"
+}
+export type AttachmentFactors = {
+    [AttachmentFactorKeys.POOL]?: string;
+    [AttachmentFactorKeys.PROXY]?: boolean;
+    [AttachmentFactorKeys.ROLE]?: string;
+};
+/**
+ * Parses a Heroku add-on attachment `namespace` string into structured factors.
+ *
+ * The namespace is a list of segments separated by `|`. Each segment must look
+ * like `key:value`, using only the **first** `:` as the separator so values may
+ * contain additional colons. Whitespace around keys and values is trimmed.
+ *
+ * Only keys listed in {@link AttachmentFactorKeys} are applied; unknown keys are
+ * ignored. For `proxy`, the value is interpreted as a boolean (`true` only when
+ * the trimmed string is exactly `"true"`). For `pool` and `role`, the value is
+ * kept as a string. If the same key appears more than once, the last occurrence
+ * wins.
+ */
+export declare function parseAttachmentFactors(namespace?: null | string): AttachmentFactors;
+export {};

package/dist/resources/data/internal/parse-attachment-factors.js

@@ -0,0 +1,37 @@
+var AttachmentFactorKeys;
+(function (AttachmentFactorKeys) {
+    AttachmentFactorKeys["POOL"] = "pool";
+    AttachmentFactorKeys["PROXY"] = "proxy";
+    AttachmentFactorKeys["ROLE"] = "role";
+})(AttachmentFactorKeys || (AttachmentFactorKeys = {}));
+/**
+ * Parses a Heroku add-on attachment `namespace` string into structured factors.
+ *
+ * The namespace is a list of segments separated by `|`. Each segment must look
+ * like `key:value`, using only the **first** `:` as the separator so values may
+ * contain additional colons. Whitespace around keys and values is trimmed.
+ *
+ * Only keys listed in {@link AttachmentFactorKeys} are applied; unknown keys are
+ * ignored. For `proxy`, the value is interpreted as a boolean (`true` only when
+ * the trimmed string is exactly `"true"`). For `pool` and `role`, the value is
+ * kept as a string. If the same key appears more than once, the last occurrence
+ * wins.
+ */
+export function parseAttachmentFactors(namespace) {
+    const result = {};
+    if (!namespace?.trim()) {
+        return result;
+    }
+    for (const factor of namespace.split('|')) {
+        const parts = factor.match(/^([^:]+):(.*)$/) ?? [];
+        if (parts.length !== 3) {
+            continue;
+        }
+        const key = parts[1].trim();
+        const value = (key === AttachmentFactorKeys.PROXY ? parts[2].trim() === 'true' : parts[2].trim());
+        if (Object.values(AttachmentFactorKeys).includes(key)) {
+            Object.assign(result, { [key]: value });
+        }
+    }
+    return result;
+}

package/dist/resources/data/internal/postgres-utils.d.ts

@@ -1,10 +1,13 @@
 import type { AddOn } from '@heroku/types/3.sdk';
+import { PostgresCredentialInfoResult as AdvancedCredentialInfo } from '@heroku/types/data';
 import type { ResourceCtx } from '../../../core/extend-resource.js';
 import type { AddOnAttachmentWithInclusions } from '../../platform/add-on-attachment/resolve.js';
+import { CredentialInfo as NonAdvancedCredentialInfo } from '../postgres-database.js';
 /**
  * Returns the first legacy database add-on on the app.
  */
 export declare function findLegacyDatabase(ctx: Pick<ResourceCtx, 'platform'>, appIdentity: string): Promise<AddOn>;
+export declare function isAdvancedCredential(credential: AdvancedCredentialInfo | NonAdvancedCredentialInfo): credential is AdvancedCredentialInfo;
 export declare const getPostgresServiceName: () => string;
 /**
  * `AddOnAttachmentWithInclusions` is an internal type. The public `isPostgresAddon` takes `AddOn` only.
@@ -13,3 +16,6 @@ export declare const isPostgresAddonInternal: (addon: AddOn | AddOnAttachmentWit
 export declare const isPostgresAddon: (addon: AddOn) => boolean;
 export declare const isAdvancedDatabase: (addon: AddOn) => boolean;
 export declare const isLegacyDatabase: (addon: AddOn) => boolean;
+export declare const isLegacyEssentialDatabase: (addon: AddOn) => boolean;
+export declare const isEssentialDatabase: (addon: AddOn) => boolean;
+export declare const isEssentialTier: (addon: AddOn) => boolean;

package/dist/resources/data/internal/postgres-utils.js

@@ -11,6 +11,9 @@ export async function findLegacyDatabase(ctx, appIdentity) {
         throw new Error(`No Heroku Postgres legacy database on ${appIdentity}`);
     return addon;
 }
+export function isAdvancedCredential(credential) {
+    return 'roles' in credential;
+}
 export const getPostgresServiceName = () => process.env.HEROKU_POSTGRESQL_ADDON_NAME || process.env.HEROKU_DATA_SERVICE || 'heroku-postgresql';
 /**
  * `AddOnAttachmentWithInclusions` is an internal type. The public `isPostgresAddon` takes `AddOn` only.
@@ -19,3 +22,6 @@ export const isPostgresAddonInternal = (addon) => addon.plan?.name?.split(':', 2
 export const isPostgresAddon = (addon) => isPostgresAddonInternal(addon);
 export const isAdvancedDatabase = (addon) => isPostgresAddonInternal(addon) && /^(advanced|performance)/.test(addon.plan?.name?.split(':', 2)[1] ?? '');
 export const isLegacyDatabase = (addon) => isPostgresAddonInternal(addon) && !isAdvancedDatabase(addon);
+export const isLegacyEssentialDatabase = (addon) => isLegacyDatabase(addon) && /^(dev|basic|mini)/.test(addon.plan?.name?.split(':', 2)[1] ?? '');
+export const isEssentialDatabase = (addon) => isLegacyDatabase(addon) && (addon.plan?.name?.split(':', 2)[1] ?? '').startsWith('essential');
+export const isEssentialTier = (addon) => isEssentialDatabase(addon) || isLegacyEssentialDatabase(addon);

package/dist/resources/data/postgres-database.d.ts

@@ -12,7 +12,7 @@ export type CredentialInfo = {
     database: string;
     host: string;
     name: string;
-    port: string;
+    port: number;
     state: string;
     uuid: string;
 };
@@ -20,4 +20,5 @@ export declare function listCredentials(ctx: Pick<ResourceCtx, 'data' | 'platfor
 export declare const postgresDatabaseExtensions: import("../../core/extend-resource.js").ResourceExtension<"data", "postgresDatabase", {
     listCredentials: (appIdentity: string, addonIdentity?: string, options?: ListCredentialsOptions) => Promise<CredentialInfo[]>;
 }>;
-export { findLegacyDatabase, getPostgresServiceName, isAdvancedDatabase, isLegacyDatabase, isPostgresAddon, } from './internal/postgres-utils.js';
+export { type AttachmentFactors, parseAttachmentFactors, } from './internal/parse-attachment-factors.js';
+export { findLegacyDatabase, getPostgresServiceName, isAdvancedCredential, isAdvancedDatabase, isEssentialDatabase, isEssentialTier, isLegacyDatabase, isLegacyEssentialDatabase, isPostgresAddon, } from './internal/postgres-utils.js';

package/dist/resources/data/postgres-database.js

@@ -11,4 +11,5 @@ export async function listCredentials(ctx, appIdentity, addonIdentity, options =
 export const postgresDatabaseExtensions = extendResource('data', 'postgresDatabase', ctx => ({
     listCredentials: (appIdentity, addonIdentity, options) => listCredentials(ctx, appIdentity, addonIdentity, options),
 }));
-export { findLegacyDatabase, getPostgresServiceName, isAdvancedDatabase, isLegacyDatabase, isPostgresAddon, } from './internal/postgres-utils.js';
+export { parseAttachmentFactors, } from './internal/parse-attachment-factors.js';
+export { findLegacyDatabase, getPostgresServiceName, isAdvancedCredential, isAdvancedDatabase, isEssentialDatabase, isEssentialTier, isLegacyDatabase, isLegacyEssentialDatabase, isPostgresAddon, } from './internal/postgres-utils.js';

package/dist/resources/extensions/data.d.ts

@@ -1,3 +1,4 @@
+export { databaseCredentialExtensions } from '../data/database-credential/index.js';
 export { databaseExtensions } from '../data/database.js';
 export { maintenanceExtensions } from '../data/maintenance.js';
 export { postgresDatabaseExtensions } from '../data/postgres-database.js';

package/dist/resources/extensions/data.js

@@ -1,3 +1,4 @@
+export { databaseCredentialExtensions } from '../data/database-credential/index.js';
 export { databaseExtensions } from '../data/database.js';
 export { maintenanceExtensions } from '../data/maintenance.js';
 export { postgresDatabaseExtensions } from '../data/postgres-database.js';

package/dist/resources/platform/dyno/exec.d.ts

@@ -109,8 +109,13 @@ export type ExchangeExecCredentialsOptions = {
  * `Authorization` header survive). The caller feeds the returned info,
  * plus the private key it holds, to its own SSH transport; the SDK does
  * not open the connection.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the custom-host
+ * client. Standalone callers omit it, and the client falls back to the
+ * pre-threading bare construction.
  */
-export declare function exchangeExecCredentials(appIdentity: string, options: ExchangeExecCredentialsOptions): Promise<ExecCredentials>;
+export declare function exchangeExecCredentials(appIdentity: string, options: ExchangeExecCredentialsOptions, ctx?: Pick<ResourceCtx, 'makeClient'>): Promise<ExecCredentials>;
 /** A running exec reservation, as reported by the exec-manager status endpoint. */
 export type ExecReservation = {
     [key: string]: unknown;
@@ -130,5 +135,10 @@ export type ExecStatusOptions = {
  * custom-host Basic-auth setup as {@link exchangeExecCredentials}. The
  * caller correlates each reservation's `dyno_name` with live dyno state
  * for display.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the custom-host
+ * client. Standalone callers omit it, and the client falls back to the
+ * pre-threading bare construction.
  */
-export declare function execStatus(appIdentity: string, options: ExecStatusOptions): Promise<ExecReservation[]>;
+export declare function execStatus(appIdentity: string, options: ExecStatusOptions, ctx?: Pick<ResourceCtx, 'makeClient'>): Promise<ExecReservation[]>;

package/dist/resources/platform/dyno/exec.js

@@ -1,4 +1,5 @@
-import { HerokuApiClient, NotFoundError } from '@heroku/heroku-fetch';
+import { NotFoundError } from '@heroku/heroku-fetch';
+import { makeCustomHostClient } from '../../../core/extend-resource.js';
 import { withSignal } from '../../../core/with-signal.js';
 import { wait } from '../../../utils/wait.js';
 import { waitForInfo } from './wait-for-info.js';
@@ -107,11 +108,16 @@ export async function restartForExec(ctx, appIdentity, dynoIdentity, options = {
  * `Authorization` header survive). The caller feeds the returned info,
  * plus the private key it holds, to its own SSH transport; the SDK does
  * not open the connection.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the custom-host
+ * client. Standalone callers omit it, and the client falls back to the
+ * pre-threading bare construction.
  */
-export async function exchangeExecCredentials(appIdentity, options) {
+export async function exchangeExecCredentials(appIdentity, options, ctx = {}) {
     options.signal?.throwIfAborted();
     const endpoint = resolveExecEndpoint(appIdentity, options.apiKey, options.configVars);
-    const client = newExecClient(endpoint.baseUrl, options.clientOptions);
+    const client = newExecClient(endpoint.baseUrl, options.clientOptions, ctx);
     const path = `${endpoint.apiPath}/${encodeURIComponent(options.dyno)}`;
     const response = await client.put(path, { client_key: options.publicKey }, {
         headers: {
@@ -130,11 +136,16 @@ export async function exchangeExecCredentials(appIdentity, options) {
  * custom-host Basic-auth setup as {@link exchangeExecCredentials}. The
  * caller correlates each reservation's `dyno_name` with live dyno state
  * for display.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the custom-host
+ * client. Standalone callers omit it, and the client falls back to the
+ * pre-threading bare construction.
  */
-export async function execStatus(appIdentity, options) {
+export async function execStatus(appIdentity, options, ctx = {}) {
     options.signal?.throwIfAborted();
     const endpoint = resolveExecEndpoint(appIdentity, options.apiKey, options.configVars);
-    const client = newExecClient(endpoint.baseUrl, options.clientOptions);
+    const client = newExecClient(endpoint.baseUrl, options.clientOptions, ctx);
     const response = await client.get(endpoint.apiPath, {
         headers: { ...options.headers, Authorization: endpoint.authorization },
         signal: options.signal,
@@ -169,10 +180,13 @@ function resolveExecEndpoint(appIdentity, apiKey, configVars) {
         baseUrl: `${url.protocol}//${url.host}`,
     };
 }
-function newExecClient(baseUrl, clientOptions) {
-    return new HerokuApiClient({
-        ...clientOptions, baseUrl, service: 'custom', token: '',
-    });
+function newExecClient(baseUrl, clientOptions, ctx = {}) {
+    // exec-manager is a custom host with Basic auth embedded per request. The
+    // custom-host client forces `token: ''` and inherits only the SDK's identity
+    // (User-Agent) and signal — never `reauthorize`/headers, so a bad-Basic 401
+    // can't drive a spurious `heroku login`. The caller's `clientOptions` still
+    // apply on top.
+    return makeCustomHostClient(ctx, baseUrl, clientOptions);
 }
 function toBasicAuth(username, password) {
     return `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`;

package/dist/resources/platform/dyno/index.js

@@ -35,10 +35,10 @@ export async function restartDynos(ctx, appIdentity, target, options = {}) {
 }
 export const dynoExtensions = extendResource('platform', 'dyno', ctx => ({
     enableExec: (appIdentity, options) => (enableExec(ctx, appIdentity, options)),
-    exchangeExecCredentials: (appIdentity, options) => (exchangeExecCredentials(appIdentity, options)),
+    exchangeExecCredentials: (appIdentity, options) => (exchangeExecCredentials(appIdentity, options, ctx)),
     execPrereqs: (appIdentity, options) => (execPrereqs(ctx, appIdentity, options)),
-    execStatus: (appIdentity, options) => (execStatus(appIdentity, options)),
-    listExtended: (appIdentity, options) => (listExtended(appIdentity, options)),
+    execStatus: (appIdentity, options) => (execStatus(appIdentity, options, ctx)),
+    listExtended: (appIdentity, options) => (listExtended(appIdentity, options, ctx)),
     restart: (appIdentity, target, options) => (restartDynos(ctx, appIdentity, target, options)),
     restartForExec: (appIdentity, dynoIdentity, options) => (restartForExec(ctx, appIdentity, dynoIdentity, options)),
     run: (appIdentity, command, options) => (runDyno(ctx, appIdentity, command, options)),

package/dist/resources/platform/dyno/list-extended.d.ts

@@ -1,5 +1,6 @@
 import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
 import type { Dyno } from '@heroku/types/3.sdk';
+import type { ResourceCtx } from '../../../core/extend-resource.js';
 /**
  * Operational detail the platform attaches to each dyno only when the
  * `?extended=true` query is used with the `version=3.sdk` Accept
@@ -46,5 +47,10 @@ export type ListExtendedOptions = {
  *
  * Unlike the routes client, this does not auto-paginate — it issues a
  * single GET, matching the historical CLI behavior.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the bare client.
+ * Standalone callers omit it, and the client falls back to the pre-threading
+ * bare construction.
  */
-export declare function listExtended(appIdentity: string, options?: ListExtendedOptions): Promise<DynoExtended[]>;
+export declare function listExtended(appIdentity: string, options?: ListExtendedOptions, ctx?: Pick<ResourceCtx, 'makeClient'>): Promise<DynoExtended[]>;

package/dist/resources/platform/dyno/list-extended.js

@@ -1,4 +1,4 @@
-import { HerokuApiClient } from '@heroku/heroku-fetch';
+import { makeCtxClient } from '../../../core/extend-resource.js';
 const ACCEPT_EXTENDED = 'application/vnd.heroku+json; version=3.sdk';
 /**
  * List an app's dynos with the extended operational detail block.
@@ -12,10 +12,15 @@ const ACCEPT_EXTENDED = 'application/vnd.heroku+json; version=3.sdk';
  *
  * Unlike the routes client, this does not auto-paginate — it issues a
  * single GET, matching the historical CLI behavior.
+ *
+ * @param ctx - Internal: supplied by the SDK's dyno extension to thread the
+ * resolved client identity and cancellation signal into the bare client.
+ * Standalone callers omit it, and the client falls back to the pre-threading
+ * bare construction.
  */
-export async function listExtended(appIdentity, options = {}) {
+export async function listExtended(appIdentity, options = {}, ctx = {}) {
     options.signal?.throwIfAborted();
-    const apiClient = new HerokuApiClient({
+    const apiClient = makeCtxClient(ctx, 'platform', {
         ...options.clientOptions,
         service: 'platform',
     });

package/dist/resources/platform/dyno/run.d.ts

@@ -73,4 +73,4 @@ export type RunDynoOptions = {
  * open their own interactive session; the SDK does not establish the
  * session, spawn ssh, or manage TTY state.
  */
-export declare function runDyno(ctx: Pick<ResourceCtx, 'platform'>, appIdentity: string, command: string, options?: RunDynoOptions): Promise<Dyno>;
+export declare function runDyno(ctx: Pick<ResourceCtx, 'makeClient' | 'platform'>, appIdentity: string, command: string, options?: RunDynoOptions): Promise<Dyno>;

package/dist/resources/platform/dyno/run.js

@@ -1,4 +1,5 @@
-import { HerokuApiClient, HerokuApiError } from '@heroku/heroku-fetch';
+import { HerokuApiError } from '@heroku/heroku-fetch';
+import { makeCtxClient } from '../../../core/extend-resource.js';
 import { withSignal } from '../../../core/with-signal.js';
 const DEFAULT_RUN_RETRIES = 2;
 const ACCEPT_RUN_INSIDE = 'application/vnd.heroku+json; version=3.sdk';
@@ -59,7 +60,7 @@ export async function runDyno(ctx, appIdentity, command, options = {}) {
 }
 async function postRun(ctx, appIdentity, body, options) {
     if (options.dyno) {
-        const apiClient = new HerokuApiClient({
+        const apiClient = makeCtxClient(ctx, 'platform', {
             ...options.clientOptions,
             service: 'platform',
         });

package/dist/resources/platform/log-session/index.d.ts

@@ -95,7 +95,7 @@ export type StreamLogsOptions = {
  *   - non-2xx response from the logplex URL
  *   - errors thrown by `logSession.create` (auth, app-not-found, etc.)
  */
-export declare function streamLogs(ctx: Pick<ResourceCtx, 'platform'>, appIdentity: string, options?: StreamLogsOptions): AsyncGenerator<string, void, unknown>;
+export declare function streamLogs(ctx: Pick<ResourceCtx, 'makeClient' | 'platform'>, appIdentity: string, options?: StreamLogsOptions): AsyncGenerator<string, void, unknown>;
 export declare const logSessionExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "logSession", {
     parseHerokuLogLine: typeof parseHerokuLogLine;
     streamLogs: (appIdentity: string, options?: StreamLogsOptions) => AsyncGenerator<string, void, unknown>;

package/dist/resources/platform/log-session/index.js

@@ -1,6 +1,5 @@
-import { HerokuApiClient } from '@heroku/heroku-fetch';
 import createDebug from 'debug';
-import { extendResource } from '../../../core/extend-resource.js';
+import { extendResource, makeCustomHostClient } from '../../../core/extend-resource.js';
 import { withSignal } from '../../../core/with-signal.js';
 import { getGeneration } from '../app/index.js';
 import { parseHerokuLogLine } from './parser.js';
@@ -68,15 +67,12 @@ export async function* streamLogs(ctx, appIdentity, options = {}) {
         try {
             // Logplex URLs hit a region-specific stream host (e.g.
             // virginia.sessions.logs.heroku.com). The token is embedded in
-            // the URL, so we use a custom-service client with no auth and
-            // a per-call baseUrl; this also picks up heroku-fetch's
-            // env-var proxy support.
+            // the URL, so we use a custom-host client with no auth and a
+            // per-call baseUrl, inheriting only the SDK's identity and
+            // cancellation; this also picks up heroku-fetch's env-var proxy
+            // support.
             const parsed = new URL(session.logplex_url);
-            const logplexClient = new HerokuApiClient({
-                baseUrl: parsed.origin,
-                service: 'custom',
-                token: '',
-            });
+            const logplexClient = makeCustomHostClient(ctx, parsed.origin);
             // Fir's telemetry-proxy sends newline-delimited plain text by
             // default, but concatenates records with zero delimiter bytes —
             // splitting on '\n' yields nothing. Requesting SSE flips the

package/dist/resources/platform/pipeline/index.d.ts

@@ -1,5 +1,5 @@
+import type { HerokuApiClientOptions } from '@heroku/heroku-fetch';
 import type { Pipeline } from '@heroku/types/3.sdk';
-import { type HerokuApiClientOptions } from '@heroku/heroku-fetch';
 import type { ResourceCtx } from '../../../core/extend-resource.js';
 export type ResolvePipelineOptions = {
     clientOptions?: HerokuApiClientOptions;
@@ -47,7 +47,7 @@ export declare class PipelineAmbiguousError extends Error {
  *     that want to prompt the user should catch this and inspect
  *     `error.matches`.
  */
-export declare function resolvePipeline(ctx: Pick<ResourceCtx, 'platform'>, identity: string, options?: ResolvePipelineOptions): Promise<Pipeline>;
+export declare function resolvePipeline(ctx: Pick<ResourceCtx, 'makeClient' | 'platform'>, identity: string, options?: ResolvePipelineOptions): Promise<Pipeline>;
 export declare const pipelineExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "pipeline", {
     resolve: (identity: string, options?: ResolvePipelineOptions) => Promise<Pipeline>;
 }>;

package/dist/resources/platform/pipeline/index.js

@@ -1,5 +1,4 @@
-import { HerokuApiClient } from '@heroku/heroku-fetch';
-import { extendResource } from '../../../core/extend-resource.js';
+import { extendResource, makeCtxClient } from '../../../core/extend-resource.js';
 import { withSignal } from '../../../core/with-signal.js';
 export class PipelineNotFoundError extends Error {
     identity;
@@ -56,7 +55,7 @@ export async function resolvePipeline(ctx, identity, options = {}) {
         // Bind the signal so the lookup aborts in flight.
         return withSignal(ctx.platform, options.signal).pipeline.info(identity);
     }
-    const apiClient = new HerokuApiClient({
+    const apiClient = makeCtxClient(ctx, 'platform', {
         ...options.clientOptions,
         service: 'platform',
     });

package/dist/resources/platform/pipeline/promotion.d.ts

@@ -15,7 +15,7 @@ export type PromotePipelineResult = {
     promotion: PipelinePromotion;
     targets: PipelinePromotionTarget[];
 };
-export declare function promotePipeline(ctx: Pick<ResourceCtx, 'platform'>, body: PipelinePromotionCreateOpts, options?: PromotePipelineOptions): Promise<PromotePipelineResult>;
+export declare function promotePipeline(ctx: Pick<ResourceCtx, 'makeClient' | 'platform'>, body: PipelinePromotionCreateOpts, options?: PromotePipelineOptions): Promise<PromotePipelineResult>;
 export declare const pipelinePromotionExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "pipelinePromotion", {
     promote: (body: PipelinePromotionCreateOpts, options?: PromotePipelineOptions) => Promise<PromotePipelineResult>;
 }>;

package/dist/resources/platform/pipeline/promotion.js

@@ -1,6 +1,5 @@
-import { HerokuApiClient } from '@heroku/heroku-fetch';
 import createDebug from 'debug';
-import { extendResource } from '../../../core/extend-resource.js';
+import { extendResource, makeCustomHostClient } from '../../../core/extend-resource.js';
 import { withSignal } from '../../../core/with-signal.js';
 import { isAbortError } from '../../../utils/is-abort-error.js';
 import { wait } from '../../../utils/wait.js';
@@ -20,7 +19,7 @@ export async function promotePipeline(ctx, body, options = {}) {
     debug('promote created promotion=%s intervalMs=%d timeoutMs=%s', promotion.id, intervalMs, timeoutMs ?? '<none>');
     const deadline = timeoutMs === undefined ? undefined : Date.now() + timeoutMs;
     const streamRunner = onReleaseStream
-        ? createReleaseStreamRunner(platform, onReleaseStream, releaseStreamMaxAttempts, intervalMs, signal)
+        ? createReleaseStreamRunner(ctx, platform, onReleaseStream, releaseStreamMaxAttempts, intervalMs, signal)
         : undefined;
     let poll = 0;
     while (true) {
@@ -48,7 +47,7 @@ export async function promotePipeline(ctx, body, options = {}) {
  * output stream and hands it to `onReleaseStream`. Subsequent calls are
  * no-ops; the stream is one-shot per promotion.
  */
-function createReleaseStreamRunner(platform, onReleaseStream, releaseStreamMaxAttempts, intervalMs, signal) {
+function createReleaseStreamRunner(ctx, platform, onReleaseStream, releaseStreamMaxAttempts, intervalMs, signal) {
     let handled = false;
     return async (targets) => {
         if (handled || targets.length !== 1)
@@ -64,24 +63,21 @@ function createReleaseStreamRunner(platform, onReleaseStream, releaseStreamMaxAt
             return;
         }
         debug('promote release-stream fetching url=%s maxAttempts=%d', release.output_stream_url, releaseStreamMaxAttempts);
-        const stream = await fetchReleaseOutput(release.output_stream_url, releaseStreamMaxAttempts, intervalMs, signal);
+        const stream = await fetchReleaseOutput(ctx, release.output_stream_url, releaseStreamMaxAttempts, intervalMs, signal);
         await onReleaseStream({ stream, target });
     };
 }
 export const pipelinePromotionExtensions = extendResource('platform', 'pipelinePromotion', ctx => ({
     promote: (body, options) => promotePipeline(ctx, body, options),
 }));
-async function fetchReleaseOutput(url, maxAttempts, intervalMs, signal) {
+async function fetchReleaseOutput(ctx, url, maxAttempts, intervalMs, signal) {
     const parsed = new URL(url);
     const path = `${parsed.pathname}${parsed.search}`;
     // The release output URL points at a third-party stream host (e.g. busl).
-    // Use a custom-service client so the platform prefixUrl and bearer token
-    // don't leak across origins.
-    const buslClient = new HerokuApiClient({
-        baseUrl: parsed.origin,
-        service: 'custom',
-        token: '',
-    });
+    // Use a custom-host client so the platform prefixUrl, bearer token, and
+    // other auth/routing options don't leak across origins, while still
+    // inheriting the SDK's identity (User-Agent) and cancellation signal.
+    const buslClient = makeCustomHostClient(ctx, parsed.origin);
     let attempt = 0;
     while (true) {
         signal?.throwIfAborted();

package/dist/version.d.ts

@@ -0,0 +1 @@
+export declare const SDK_VERSION = "0.12.1";

package/dist/version.js

@@ -0,0 +1,2 @@
+// Generated from package.json by scripts/write-version.mjs (build prebuild). Do not edit.
+export const SDK_VERSION = '0.12.1';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heroku/sdk",
-  "version": "0.11.2",
+  "version": "0.12.1",
   "description": "Heroku SDK",
   "author": "Heroku",
   "type": "module",
@@ -102,6 +102,10 @@
       "types": "./dist/resources/platform/vpn-connection/index.d.ts",
       "default": "./dist/resources/platform/vpn-connection/index.js"
     },
+    "./resources/data/database-credential": {
+      "types": "./dist/resources/data/database-credential/index.d.ts",
+      "default": "./dist/resources/data/database-credential/index.js"
+    },
     "./resources/data/redis": {
       "types": "./dist/resources/data/redis/index.d.ts",
       "default": "./dist/resources/data/redis/index.js"
@@ -123,19 +127,24 @@
   },
   "scripts": {
     "clean": "rimraf dist",
+    "generate:version": "node scripts/write-version.mjs",
+    "prebuild": "npm run generate:version",
     "build": "npm run clean && tsc",
+    "prelint": "npm run generate:version",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
+    "pretest": "npm run generate:version",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage --coverage.reporter=text-summary --coverage.reporter=lcovonly",
+    "pretest:types": "npm run generate:version",
     "test:types": "tsc --noEmit -p tsconfig.type-tests.json",
     "prepare": "npm run build",
     "example": "tsx"
   },
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "files": [
     "dist"
@@ -144,17 +153,17 @@
     "@heroku-cli/test-utils": "^1.0.3",
     "@types/debug": "^4.1.12",
     "@types/node": "^26.5.1",
-    "@vitest/coverage-v8": "^4.1.8",
+    "@vitest/coverage-v8": "^5.0.5",
+    "@vitest/eslint-plugin": "^1.6.0",
     "eslint": "^9.39.4",
     "eslint-config-oclif": "^6.0.167",
-    "@vitest/eslint-plugin": "^1.6.0",
     "rimraf": "^6.1.3",
     "tsx": "^4.22.4",
     "typescript": "^6.0.2",
-    "vitest": "^4.1.4"
+    "vitest": "^5.0.5"
   },
   "dependencies": {
-    "@heroku/heroku-fetch": "^0.2.0",
+    "@heroku/heroku-fetch": "^0.2.3",
     "@heroku/types": "^5.0.0",
     "debug": "^4.4.0"
   }