@heroku/sdk 0.5.2 → 0.5.3

package/dist/resources/platform/sni-endpoint/index.js

@@ -0,0 +1,6 @@
+import { extendResource } from '../../../core/extend-resource.js';
+import { createAndAssociate } from './create-and-associate.js';
+export { createAndAssociate } from './create-and-associate.js';
+export const sniEndpointExtensions = extendResource('platform', 'sniEndpoint', ctx => ({
+    createAndAssociate: (appIdentity, certificateChain, privateKey, options) => createAndAssociate(ctx, appIdentity, certificateChain, privateKey, options),
+}));

package/dist/resources/platform/telemetry-drain/index.d.ts

@@ -0,0 +1,6 @@
+import type { TelemetryDrainOptions, TelemetryDrainTarget } from './types.js';
+export { removeDrainsForTarget } from './remove-drains-for-target.js';
+export type { TelemetryDrainOptions, TelemetryDrainTarget } from './types.js';
+export declare const telemetryDrainExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "telemetryDrain", {
+    removeDrains: (target: TelemetryDrainTarget, options?: TelemetryDrainOptions) => Promise<import("@heroku/types/3.sdk").TelemetryDrain[]>;
+}>;

package/dist/resources/platform/telemetry-drain/index.js

@@ -0,0 +1,6 @@
+import { extendResource } from '../../../core/extend-resource.js';
+import { removeDrainsForTarget } from './remove-drains-for-target.js';
+export { removeDrainsForTarget } from './remove-drains-for-target.js';
+export const telemetryDrainExtensions = extendResource('platform', 'telemetryDrain', ctx => ({
+    removeDrains: (target, options) => removeDrainsForTarget(ctx, target, options),
+}));

package/dist/resources/platform/telemetry-drain/remove-drains-for-target.d.ts

@@ -0,0 +1,13 @@
+import type { TelemetryDrain } from '@heroku/types/3.sdk';
+import type { ResourceCtx } from '../../../core/extend-resource.js';
+import type { TelemetryDrainOptions, TelemetryDrainTarget } from './types.js';
+/**
+ * Remove all telemetry drains for a given app or space.
+ *
+ * Behavior:
+ * - Dispatches to listByApp or listBySpace based on target discriminant
+ * - Deletes all drains in parallel via Promise.all
+ * - Returns empty array if no drains exist
+ * - Rejects if any individual delete fails
+ */
+export declare function removeDrainsForTarget(ctx: Pick<ResourceCtx, 'platform'>, target: TelemetryDrainTarget, options?: TelemetryDrainOptions): Promise<TelemetryDrain[]>;

package/dist/resources/platform/telemetry-drain/remove-drains-for-target.js

@@ -0,0 +1,25 @@
+/**
+ * Remove all telemetry drains for a given app or space.
+ *
+ * Behavior:
+ * - Dispatches to listByApp or listBySpace based on target discriminant
+ * - Deletes all drains in parallel via Promise.all
+ * - Returns empty array if no drains exist
+ * - Rejects if any individual delete fails
+ */
+export async function removeDrainsForTarget(ctx, target, options = {}) {
+    const { signal } = options;
+    const { app, space } = target;
+    signal?.throwIfAborted();
+    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    let drains = [];
+    if (app) {
+        drains = await platform.telemetryDrain.listByApp(app);
+    }
+    else if (space) {
+        drains = await platform.telemetryDrain.listBySpace(space);
+    }
+    signal?.throwIfAborted();
+    const deletedDrains = await Promise.all(drains.map(drain => platform.telemetryDrain.delete(drain.id)));
+    return deletedDrains;
+}

package/dist/resources/platform/telemetry-drain/types.d.ts

@@ -0,0 +1,13 @@
+export type TelemetryDrainOptions = {
+    /**
+     * Abort signal to cancel the operation.
+     */
+    signal?: AbortSignal;
+};
+export type TelemetryDrainTarget = {
+    app: string;
+    space?: never;
+} | {
+    app?: never;
+    space: string;
+};

package/dist/resources/platform/telemetry-drain/types.js

@@ -0,0 +1 @@
+export {};

package/dist/resources/platform/test-run/index.d.ts

@@ -0,0 +1,5 @@
+import { type TestRunStatus, type WaitForStateOptions } from './wait-for-state.js';
+export { TestRunNotReadyError, type TestRunStatus, waitForState, type WaitForStateOptions, } from './wait-for-state.js';
+export declare const testRunExtensions: import("../../../core/extend-resource.js").ResourceExtension<"platform", "testRun", {
+    waitForState: (pipelineId: string, testRunNumber: number, targetStates: ReadonlyArray<string | TestRunStatus>, options?: WaitForStateOptions) => Promise<import("@heroku/types/3.sdk").TestRun>;
+}>;

package/dist/resources/platform/test-run/index.js

@@ -0,0 +1,9 @@
+import { extendResource } from '../../../core/extend-resource.js';
+import { waitForState } from './wait-for-state.js';
+export { TestRunNotReadyError, waitForState, } from './wait-for-state.js';
+// Resource key MUST be the camelCase `'testRun'` — it matches the generated
+// route-group export name that `mergeExtensions` looks up on the platform
+// client. The directory stays kebab (`test-run/`).
+export const testRunExtensions = extendResource('platform', 'testRun', ctx => ({
+    waitForState: (pipelineId, testRunNumber, targetStates, options) => waitForState(ctx, pipelineId, testRunNumber, targetStates, options),
+}));

package/dist/resources/platform/test-run/wait-for-state.d.ts

@@ -0,0 +1,68 @@
+import type { TestRun } from '@heroku/types/3.sdk';
+import type { ResourceCtx } from '../../../core/extend-resource.js';
+/**
+ * The documented `TestRun.status` values from the Platform API. Provided
+ * for autocomplete in {@link waitForState}'s `targetStates`; the runtime
+ * comparison is plain string membership (`targetStates.includes(run.status)`),
+ * so any string is accepted.
+ */
+export type TestRunStatus = TestRun['status'];
+/**
+ * Thrown by {@link waitForState} when the test run did not reach one of
+ * `targetStates` within `timeoutMs`. Carries the last observed run so
+ * callers can branch on its terminal `status` (e.g. distinguish a
+ * `failed` run from one still `building`). Mirrors `DynoNotReadyError`.
+ */
+export declare class TestRunNotReadyError extends Error {
+    readonly testRun: TestRun;
+    readonly expectedStates: ReadonlyArray<string>;
+    readonly timeoutMs: number;
+    readonly id = "test_run_not_ready";
+    constructor(testRun: TestRun, expectedStates: ReadonlyArray<string>, timeoutMs: number);
+}
+export type WaitForStateOptions = {
+    /**
+     * Delay between polls in milliseconds. Defaults to 1000.
+     */
+    intervalMs?: number;
+    /**
+     * Fires after every successful `testRun.infoByPipeline` call, including
+     * runs whose `status` does not yet match `targetStates` (and trigger
+     * another poll) AND the final matching run before it is returned. Use
+     * this to surface live state transitions in a UI. Exceptions thrown from
+     * this callback propagate and end the wait — there is no implicit catch.
+     */
+    onPoll?: (run: TestRun) => void;
+    /**
+     * Cancels the wait early. If already aborted, {@link waitForState}
+     * rejects before the first poll; if aborted mid-wait, the pending delay
+     * rejects with `signal.reason`.
+     */
+    signal?: AbortSignal;
+    /**
+     * Wall-clock budget in milliseconds before {@link TestRunNotReadyError}
+     * is thrown. Defaults to 600000 (10 minutes) — a finite default so a
+     * stuck run can't hang forever. Pass a larger value for long CI runs.
+     */
+    timeoutMs?: number;
+};
+/**
+ * Poll `testRun.infoByPipeline` until the run's `status` is one of
+ * `targetStates`, then return that run. Reuses the SDK's cancellable
+ * `wait()` helper to space polls — no bare `setTimeout` loop.
+ *
+ * Transient-error handling: errors from `infoByPipeline` **propagate**;
+ * there is no 404/429/503 retry. This matches the closest precedent,
+ * `promotePipeline`, and the original CLI `waitForStates`, which had no
+ * retry either — adopting `waitForInfo`'s transient retry would be behavior
+ * the eventual CLI caller never had.
+ *
+ * On exceeding `timeoutMs` without a match, throws {@link TestRunNotReadyError}
+ * carrying the last observed run.
+ *
+ * @example
+ * ```ts
+ * const run = await platform.testRun.waitForState(pipelineId, 42, ['debugging', 'errored'])
+ * ```
+ */
+export declare function waitForState(ctx: Pick<ResourceCtx, 'platform'>, pipelineId: string, testRunNumber: number, targetStates: ReadonlyArray<string | TestRunStatus>, options?: WaitForStateOptions): Promise<TestRun>;

package/dist/resources/platform/test-run/wait-for-state.js

@@ -0,0 +1,65 @@
+import { wait } from '../../../utils/wait.js';
+const DEFAULT_INTERVAL_MS = 1000;
+// Finite default so a stuck CI test run can't hang a caller forever.
+// Diverges deliberately from `promotePipeline`, which leaves `timeoutMs`
+// unbounded; callers that need longer can pass an explicit `timeoutMs`.
+const DEFAULT_TIMEOUT_MS = 600_000;
+/**
+ * Thrown by {@link waitForState} when the test run did not reach one of
+ * `targetStates` within `timeoutMs`. Carries the last observed run so
+ * callers can branch on its terminal `status` (e.g. distinguish a
+ * `failed` run from one still `building`). Mirrors `DynoNotReadyError`.
+ */
+export class TestRunNotReadyError extends Error {
+    testRun;
+    expectedStates;
+    timeoutMs;
+    id = 'test_run_not_ready';
+    constructor(testRun, expectedStates, timeoutMs) {
+        super(`Test run #${testRun.number} did not reach status ${expectedStates.join('/')} `
+            + `within ${timeoutMs}ms (last status: ${testRun.status}).`);
+        this.testRun = testRun;
+        this.expectedStates = expectedStates;
+        this.timeoutMs = timeoutMs;
+        this.name = 'TestRunNotReadyError';
+    }
+}
+/**
+ * Poll `testRun.infoByPipeline` until the run's `status` is one of
+ * `targetStates`, then return that run. Reuses the SDK's cancellable
+ * `wait()` helper to space polls — no bare `setTimeout` loop.
+ *
+ * Transient-error handling: errors from `infoByPipeline` **propagate**;
+ * there is no 404/429/503 retry. This matches the closest precedent,
+ * `promotePipeline`, and the original CLI `waitForStates`, which had no
+ * retry either — adopting `waitForInfo`'s transient retry would be behavior
+ * the eventual CLI caller never had.
+ *
+ * On exceeding `timeoutMs` without a match, throws {@link TestRunNotReadyError}
+ * carrying the last observed run.
+ *
+ * @example
+ * ```ts
+ * const run = await platform.testRun.waitForState(pipelineId, 42, ['debugging', 'errored'])
+ * ```
+ */
+export async function waitForState(ctx, pipelineId, testRunNumber, targetStates, options = {}) {
+    const { intervalMs = DEFAULT_INTERVAL_MS, onPoll, signal, timeoutMs = DEFAULT_TIMEOUT_MS, } = options;
+    signal?.throwIfAborted();
+    // Scope the in-flight info call to the caller's signal so an abort takes
+    // effect during the API call, not just during the backoff.
+    const platform = signal ? ctx.platform.withOptions({ signal }) : ctx.platform;
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+        signal?.throwIfAborted();
+        const run = await platform.testRun.infoByPipeline(pipelineId, testRunNumber);
+        onPoll?.(run);
+        if (targetStates.includes(run.status)) {
+            return run;
+        }
+        if (Date.now() >= deadline) {
+            throw new TestRunNotReadyError(run, targetStates, timeoutMs);
+        }
+        await wait(intervalMs, signal);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heroku/sdk",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "Heroku SDK",
   "author": "Heroku",
   "type": "module",
@@ -50,6 +50,14 @@
       "types": "./dist/resources/platform/pipeline/*.d.ts",
       "default": "./dist/resources/platform/pipeline/*.js"
     },
+    "./resources/platform/test-run": {
+      "types": "./dist/resources/platform/test-run/index.d.ts",
+      "default": "./dist/resources/platform/test-run/index.js"
+    },
+    "./resources/data/redis": {
+      "types": "./dist/resources/data/redis/index.d.ts",
+      "default": "./dist/resources/data/redis/index.js"
+    },
     "./resources/*": {
       "types": "./dist/resources/*.d.ts",
       "default": "./dist/resources/*.js"
@@ -92,7 +100,7 @@
   },
   "dependencies": {
     "@heroku/heroku-fetch": "^0.1.1-beta",
-    "@heroku/types": "^3.0.0-beta",
+    "@heroku/types": "^4.0.1",
     "debug": "^4.4.0"
   }
 }