@heroku/sdk 0.12.2 → 0.12.4

package/dist/resources/data/database-credential/index.d.ts

@@ -7,7 +7,6 @@ export type DatabaseCredentialOptions = {
 export { create, type CreateDatabaseCredentialResult } from './create.js';
 export { destroy, type DestroyDatabaseCredentialResult } from './destroy.js';
 export { type GetDatabaseCredentialUrlResult, getUrl, } from './get-url.js';
-export { NotAdvancedDatabaseError } from './list.js';
 export { list, type ListDatabaseCredentialsResult } from './list.js';
 export { rotate, type RotateAllDatabaseCredentialsResult, type RotateDatabaseCredentialOptions, type RotateDatabaseCredentialOpts, type RotateDatabaseCredentialPreview, type RotateDatabaseCredentialResult, } from './rotate.js';
 export declare const databaseCredentialExtensions: import("../../../core/extend-resource.js").ResourceExtension<"data", "databaseCredential", {

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

@@ -7,7 +7,6 @@ import { rotate } from './rotate.js';
 export { create } from './create.js';
 export { destroy } from './destroy.js';
 export { getUrl, } from './get-url.js';
-export { NotAdvancedDatabaseError } from './list.js';
 export { list } from './list.js';
 export { rotate, } from './rotate.js';
 export const databaseCredentialExtensions = extendResource('data', 'databaseCredential', ctx => {

package/dist/resources/data/database-credential/list.d.ts

@@ -2,21 +2,6 @@ import type { PostgresCredentialListResult } from '@heroku/types/data';
 import type { ResourceCtx } from '../../../core/extend-resource.js';
 import type { ResolvedAddOn } from '../../platform/add-on/types.js';
 import { DatabaseCredentialOptions } from './index.js';
-/**
- * Thrown by `list` when the resolved add-on is not an Advanced-tier
- * database. Carries the resolved addon so callers that need its identity
- * (e.g. to point the user at the classic-tier equivalent) don't need a
- * second resolve call.
- */
-export declare class NotAdvancedDatabaseError extends Error {
-    readonly addon: ResolvedAddOn;
-    readonly id = "not_advanced_database";
-    constructor(addon: ResolvedAddOn);
-    get body(): {
-        id: string;
-        message: string;
-    };
-}
 export type ListDatabaseCredentialsResult = {
     addon: ResolvedAddOn;
     credentials: PostgresCredentialListResult;

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

@@ -1,24 +1,6 @@
 import { withSignal } from '../../../core/with-signal.js';
 import { resolveAddonInternal } from '../../platform/add-on/resolve.js';
-import { getPostgresServiceName, isAdvancedDatabase } from '../internal/postgres-utils.js';
-/**
- * Thrown by `list` when the resolved add-on is not an Advanced-tier
- * database. Carries the resolved addon so callers that need its identity
- * (e.g. to point the user at the classic-tier equivalent) don't need a
- * second resolve call.
- */
-export class NotAdvancedDatabaseError extends Error {
-    addon;
-    id = 'not_advanced_database';
-    constructor(addon) {
-        super(`You can only list credentials on Advanced-tier databases. ${addon.name} isn't an Advanced-tier database.`);
-        this.addon = addon;
-        this.name = 'NotAdvancedDatabaseError';
-    }
-    get body() {
-        return { id: this.id, message: this.message };
-    }
-}
+import { getPostgresServiceName, isAdvancedDatabase, NotAdvancedDatabaseError } from '../internal/postgres-utils.js';
 /**
  * Lists credentials on an Advanced-tier Postgres database. Classic-tier
  * databases don't support this endpoint; use `postgresDatabase.listCredentials`
@@ -36,7 +18,7 @@ export async function list(ctx, addonIdentity, options = {}) {
         addonService: getPostgresServiceName(), appIdentity,
     });
     if (!isAdvancedDatabase(addon)) {
-        throw new NotAdvancedDatabaseError(addon);
+        throw new NotAdvancedDatabaseError(addon, `You can only list credentials on Advanced-tier databases. ${addon.name} isn't an Advanced-tier database.`);
     }
     const data = withSignal(ctx.data, signal);
     const credentials = await data.postgresCredential.list(addon.id);

package/dist/resources/data/database-credential/rotate.d.ts

@@ -1,9 +1,8 @@
-import type { PostgresDatabaseInfoCredentialResult as NonAdvancedCredentialInfo, PostgresCredentialListResult, PostgresDatabaseRotateCredentialResult, PostgresDatabaseRotateCredentialsResult, PostgresRotateCredentialsResult } from '@heroku/types/data';
+import type { PostgresCredentialInfoResult as AdvancedCredentialInfo, PostgresDatabaseInfoCredentialResult as NonAdvancedCredentialInfo, PostgresDatabaseRotateCredentialResult, PostgresDatabaseRotateCredentialsResult, PostgresRotateCredentialsResult } from '@heroku/types/data';
 import { AddOnAttachment } from '@heroku/types/3.sdk';
 import type { ResourceCtx } from '../../../core/extend-resource.js';
 import type { ResolvedAddOn } from '../../platform/add-on/types.js';
 import type { DatabaseCredentialOptions } from './index.js';
-type AdvancedCredentialInfo = PostgresCredentialListResult['items'][number];
 export type RotateDatabaseCredentialOptions = DatabaseCredentialOptions & {
     /**
      * Fires before the rotate request, allowing the caller to perform any
@@ -53,4 +52,3 @@ export declare function rotate(ctx: Pick<ResourceCtx, 'data' | 'platform'>, addo
     all: true;
 }, options?: RotateDatabaseCredentialOptions): Promise<RotateAllDatabaseCredentialsResult>;
 export declare function rotate(ctx: Pick<ResourceCtx, 'data' | 'platform'>, addonIdentity: string, body?: RotateDatabaseCredentialOpts, options?: RotateDatabaseCredentialOptions): Promise<RotateDatabaseCredentialResult>;
-export {};

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

@@ -1,21 +1,37 @@
 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 type { ResolvedAddOnAttachment } from '../../platform/add-on-attachment/resolve.js';
 import { CredentialInfo as NonAdvancedCredentialInfo } from '../postgres-database.js';
+/**
+ * The add-on shapes the Postgres tier predicates accept: either a full
+ * platform `AddOn` or the lighter add-on carried on a resolved attachment.
+ * Both expose the `plan.name` these checks read, so they're interchangeable
+ * here.
+ */
+export type PostgresAddonLike = AddOn | ResolvedAddOnAttachment['addon'];
+/**
+ * Thrown when an add-on is not an Advanced-tier database. Carries the add-on
+ * so callers that need its identity don't need a second resolve call.
+ */
+export declare class NotAdvancedDatabaseError extends Error {
+    readonly addon: PostgresAddonLike;
+    readonly id = "not_advanced_database";
+    constructor(addon: PostgresAddonLike, message: string);
+    get body(): {
+        id: string;
+        message: string;
+    };
+}
 /**
  * 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.
- */
-export declare const isPostgresAddonInternal: (addon: AddOn | AddOnAttachmentWithInclusions["addon"]) => boolean;
-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;
+export declare const isPostgresAddon: (addon: PostgresAddonLike) => boolean;
+export declare const isAdvancedDatabase: (addon: PostgresAddonLike) => boolean;
+export declare const isLegacyDatabase: (addon: PostgresAddonLike) => boolean;
+export declare const isLegacyEssentialDatabase: (addon: PostgresAddonLike) => boolean;
+export declare const isEssentialDatabase: (addon: PostgresAddonLike) => boolean;
+export declare const isEssentialTier: (addon: PostgresAddonLike) => boolean;

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

@@ -1,5 +1,21 @@
 import createDebug from 'debug';
 const debug = createDebug('heroku:sdk:resources:postgres-database');
+/**
+ * Thrown when an add-on is not an Advanced-tier database. Carries the add-on
+ * so callers that need its identity don't need a second resolve call.
+ */
+export class NotAdvancedDatabaseError extends Error {
+    addon;
+    id = 'not_advanced_database';
+    constructor(addon, message) {
+        super(message);
+        this.addon = addon;
+        this.name = 'NotAdvancedDatabaseError';
+    }
+    get body() {
+        return { id: this.id, message: this.message };
+    }
+}
 /**
  * Returns the first legacy database add-on on the app.
  */
@@ -15,13 +31,9 @@ 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.
- */
-export const isPostgresAddonInternal = (addon) => addon.plan?.name?.split(':', 2)[0] === getPostgresServiceName();
-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 isPostgresAddon = (addon) => addon.plan?.name?.split(':', 2)[0] === getPostgresServiceName();
+export const isAdvancedDatabase = (addon) => isPostgresAddon(addon) && /^(advanced|performance)/.test(addon.plan?.name?.split(':', 2)[1] ?? '');
+export const isLegacyDatabase = (addon) => isPostgresAddon(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/internal/resolve-pg-database.js

@@ -2,7 +2,7 @@ import { NotFoundError } from '@heroku/heroku-fetch';
 import createDebug from 'debug';
 import { withSignal } from '../../../core/with-signal.js';
 import { AddonAttachmentAmbiguousError, AddonAttachmentNotFoundError, resolveAddonAttachment } from '../../platform/add-on-attachment/resolve.js';
-import { getPostgresServiceName, isPostgresAddonInternal } from './postgres-utils.js';
+import { getPostgresServiceName, isPostgresAddon } from './postgres-utils.js';
 const debug = createDebug('heroku:sdk:resources:database');
 const DEFAULT_PG_ATTACHMENT = 'DATABASE_URL';
 /**
@@ -118,7 +118,7 @@ async function listPostgresAttachments(ctx, appIdentity, attachmentId, error, si
         debug('listing attachments failed while building not-found error: %O', listError);
         throw new PgDatabaseNotFoundError(`Could not resolve ${stripUrlSuffix(attachmentId)} on ${appIdentity}`, { cause: error });
     }
-    return attachments.filter(attachment => isPostgresAddonInternal(attachment.addon));
+    return attachments.filter(attachment => isPostgresAddon(attachment.addon));
 }
 /**
  * Used by `attachmentResolutionFallback` to resolve attachments via app config vars

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

@@ -1,7 +1,63 @@
+import type { AddOnAttachment, AddOnAttachmentCreateOpts } from '@heroku/types/3.sdk';
+import type { PostgresCredentialListResult } from '@heroku/types/data';
 import type { ResourceCtx } from '../../core/extend-resource.js';
+import type { DeprovisioningAddOn, ResolvedAddOn } from '../platform/add-on/types.js';
 export type ListCredentialsOptions = {
     signal?: AbortSignal;
 };
+export type DeleteAttachmentOptions = {
+    beforeDelete?: (preview: {
+        addon: ResolvedAddOn;
+        attachment: AddOnAttachment;
+    }) => Promise<void> | void;
+    onDetached?: (attachment: AddOnAttachment) => Promise<void> | void;
+    signal?: AbortSignal;
+};
+export type DeleteAttachmentResult = {
+    addon: ResolvedAddOn;
+    attachment: AddOnAttachment;
+    releaseVersion?: number;
+};
+export type PostgresCredential = PostgresCredentialListResult['items'][number];
+export type ListAttachmentsOptions = {
+    appIdentity?: string;
+    signal?: AbortSignal;
+};
+export type ListAttachmentsResult = {
+    addon: ResolvedAddOn;
+    attachments: AddOnAttachment[];
+    credentials: PostgresCredential[];
+};
+export type CreateAttachmentBody = Omit<AddOnAttachmentCreateOpts, 'addon' | 'app'>;
+export type CreateAttachmentOptions = {
+    onAttached?: (attachment: AddOnAttachment) => Promise<void> | void;
+    signal?: AbortSignal;
+};
+export type CreateAttachmentResult = {
+    addon: ResolvedAddOn;
+    attachment: AddOnAttachment;
+    releaseVersion?: number;
+};
+export type DestroyOptions = {
+    appIdentity?: string;
+    /**
+     * Runs after the database is resolved but before the delete request fires.
+     * An abort (or throw) during the hook prevents the delete — use it to
+     * confirm destruction against the resolved add-on.
+     */
+    beforeDestroy?: (preview: {
+        addon: ResolvedAddOn;
+    }) => Promise<void> | void;
+    force?: boolean;
+    onDeprovisioning?: (addon: DeprovisioningAddOn) => Promise<void> | void;
+    signal?: AbortSignal;
+    wait?: boolean;
+    waitIntervalMs?: number;
+};
+export type DestroyResult = {
+    addon: ResolvedAddOn;
+    result: DeprovisioningAddOn;
+};
 export type CredentialInfo = {
     credentials: Array<{
         connections?: null | number;
@@ -17,8 +73,58 @@ export type CredentialInfo = {
     uuid: string;
 };
 export declare function listCredentials(ctx: Pick<ResourceCtx, 'data' | 'platform'>, appIdentity: string, addonIdentity?: string, options?: ListCredentialsOptions): Promise<CredentialInfo[]>;
+/**
+ * Looks up a Postgres attachment by name under an app, resolves its add-on,
+ * and deletes the attachment.
+ *
+ * Throws `NotAdvancedDatabaseError` (carrying the resolved add-on) if the
+ * attachment's database isn't an Advanced-tier database.
+ *
+ * If provided, `beforeDelete` runs after resolution/tier-checking but before
+ * the delete request fires (an abort during the hook prevents the delete), and
+ * `onDetached` runs once the attachment is deleted but before the release
+ * version fetch. The returned `releaseVersion` is the latest release created by
+ * unsetting the attachment's config vars.
+ */
+export declare function deleteAttachment(ctx: Pick<ResourceCtx, 'platform'>, appIdentity: string, attachmentName: string, options?: DeleteAttachmentOptions): Promise<DeleteAttachmentResult>;
+/**
+ * Resolves a Postgres database by add-on identity and lists its attachments
+ * alongside its credentials, fanning the two requests out in parallel.
+ *
+ * Resolution is scoped by `appIdentity` when given. Throws
+ * `NotAdvancedDatabaseError` (carrying the resolved add-on) if the database
+ * isn't an Advanced-tier database.
+ */
+export declare function listAttachments(ctx: Pick<ResourceCtx, 'data' | 'platform'>, addonIdentity: string, options?: ListAttachmentsOptions): Promise<ListAttachmentsResult>;
+/**
+ * Resolves a source Postgres database by add-on identity, attaches it
+ * to an app, and fetches the latest release version.
+ *
+ * Throws `NotAdvancedDatabaseError` (carrying the resolved add-on) if the
+ * database isn't an Advanced-tier database.
+ *
+ * If provided, `onAttached` fires once the attachment is created but before
+ * the release version fetch.
+ */
+export declare function createAttachment(ctx: Pick<ResourceCtx, 'platform'>, appIdentity: string, addonIdentity: string, body?: CreateAttachmentBody, options?: CreateAttachmentOptions): Promise<CreateAttachmentResult>;
+/**
+ * Resolves a Postgres database by add-on identity and destroys it.
+ *
+ * Resolution is scoped by `appIdentity` when given. If provided,
+ * `beforeDestroy` runs after resolution but before the delete request fires,
+ * so callers can confirm against the resolved add-on; an abort or throw in
+ * the hook prevents the delete. Delegates the delete (and optional
+ * deprovisioning poll when `wait` is set) to `addOn.destroyAndWait`.
+ */
+export declare function destroy(ctx: Pick<ResourceCtx, 'platform'>, addonIdentity: string, options?: DestroyOptions): Promise<DestroyResult>;
 export declare const postgresDatabaseExtensions: import("../../core/extend-resource.js").ResourceExtension<"data", "postgresDatabase", {
+    createAttachment: (appIdentity: string, addonIdentity: string, body?: CreateAttachmentBody, options?: CreateAttachmentOptions) => Promise<CreateAttachmentResult>;
+    deleteAttachment: (appIdentity: string, attachmentName: string, options?: DeleteAttachmentOptions) => Promise<DeleteAttachmentResult>;
+    destroy: (addonIdentity: string, options?: DestroyOptions) => Promise<DestroyResult>;
+    listAttachments: (addonIdentity: string, options?: ListAttachmentsOptions) => Promise<ListAttachmentsResult>;
     listCredentials: (appIdentity: string, addonIdentity?: string, options?: ListCredentialsOptions) => Promise<CredentialInfo[]>;
 }>;
+export { AddonAppMismatchError, AddonConfirmationRequiredError, AddonDestroyFailedError, AddonNotFoundError, } from '../platform/add-on/errors.js';
+export type { DeprovisioningAddOn, ResolvedAddOn } from '../platform/add-on/types.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';
+export { findLegacyDatabase, getPostgresServiceName, isAdvancedCredential, isAdvancedDatabase, isEssentialDatabase, isEssentialTier, isLegacyDatabase, isLegacyEssentialDatabase, isPostgresAddon, NotAdvancedDatabaseError, } from './internal/postgres-utils.js';

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

@@ -1,5 +1,10 @@
+import { HerokuApiError, NotFoundError } from '@heroku/heroku-fetch';
 import { extendResource } from '../../core/extend-resource.js';
 import { withSignal } from '../../core/with-signal.js';
+import { destroyAndWait } from '../platform/add-on/destroy-and-wait.js';
+import { AddonAppMismatchError, AddonConfirmationRequiredError, AddonDestroyFailedError, AddonNotFoundError, } from '../platform/add-on/errors.js';
+import { resolveAddonInternal } from '../platform/add-on/resolve.js';
+import { getPostgresServiceName, isAdvancedDatabase, NotAdvancedDatabaseError } from './internal/postgres-utils.js';
 import { resolvePgDatabase } from './internal/resolve-pg-database.js';
 export async function listCredentials(ctx, appIdentity, addonIdentity, options = {}) {
     options.signal?.throwIfAborted();
@@ -8,8 +13,209 @@ export async function listCredentials(ctx, appIdentity, addonIdentity, options =
     const data = withSignal(ctx.data, options.signal);
     return data.postgresDatabase.listCredentials(addon.id);
 }
+/**
+ * Looks up a Postgres attachment by name under an app, resolves its add-on,
+ * and deletes the attachment.
+ *
+ * Throws `NotAdvancedDatabaseError` (carrying the resolved add-on) if the
+ * attachment's database isn't an Advanced-tier database.
+ *
+ * If provided, `beforeDelete` runs after resolution/tier-checking but before
+ * the delete request fires (an abort during the hook prevents the delete), and
+ * `onDetached` runs once the attachment is deleted but before the release
+ * version fetch. The returned `releaseVersion` is the latest release created by
+ * unsetting the attachment's config vars.
+ */
+export async function deleteAttachment(ctx, appIdentity, attachmentName, options = {}) {
+    const { beforeDelete, onDetached, signal } = options;
+    signal?.throwIfAborted();
+    // Bind the signal so the lookup, delete, and release-list requests abort in flight.
+    const platform = withSignal(ctx.platform, signal);
+    const attachment = await platform.addOnAttachment.infoByApp(appIdentity, attachmentName);
+    const addon = await resolveAddonInternal(platform, attachment.addon.name, { addonService: getPostgresServiceName() });
+    if (!isAdvancedDatabase(addon)) {
+        throw new NotAdvancedDatabaseError(addon, `You can only detach Advanced-tier databases with postgresDatabase.deleteAttachment(). ${addon.name} isn't an Advanced-tier database.`);
+    }
+    await beforeDelete?.({ addon, attachment });
+    signal?.throwIfAborted();
+    const deletedAttachment = await platform.addOnAttachment.delete(attachment.id);
+    await onDetached?.(deletedAttachment);
+    signal?.throwIfAborted();
+    // The detach already succeeded; a failed release lookup shouldn't fail the
+    // whole operation. Preserve aborts, otherwise report an unknown version.
+    let releaseVersion;
+    try {
+        const releases = await platform
+            .withHeaders({ Range: 'version ..; max=1, order=desc' })
+            .release.list(appIdentity);
+        releaseVersion = releases[0]?.version;
+    }
+    catch (error) {
+        // Preserve aborts; otherwise leave releaseVersion undefined (best-effort).
+        if (signal?.aborted) {
+            throw error;
+        }
+    }
+    return { addon, attachment: deletedAttachment, releaseVersion };
+}
+/**
+ * Resolves a Postgres database by add-on identity and lists its attachments
+ * alongside its credentials, fanning the two requests out in parallel.
+ *
+ * Resolution is scoped by `appIdentity` when given. Throws
+ * `NotAdvancedDatabaseError` (carrying the resolved add-on) if the database
+ * isn't an Advanced-tier database.
+ */
+export async function listAttachments(ctx, addonIdentity, options = {}) {
+    const { appIdentity, signal } = options;
+    signal?.throwIfAborted();
+    // Bind the signal so the resolve and fan-out requests abort in flight.
+    const platform = withSignal(ctx.platform, signal);
+    const data = withSignal(ctx.data, signal);
+    const addon = await resolveAddonInternal(platform, addonIdentity, { addonService: getPostgresServiceName(), appIdentity });
+    if (!isAdvancedDatabase(addon)) {
+        throw new NotAdvancedDatabaseError(addon, `You can only list attachments on Advanced-tier databases with postgresDatabase.listAttachments(). ${addon.name} isn't an Advanced-tier database.`);
+    }
+    const [{ items: credentials }, attachments] = await Promise.all([
+        data.postgresCredential.list(addon.id),
+        platform.addOnAttachment.listByAddOn(addon.id),
+    ]);
+    return { addon, attachments, credentials };
+}
+/**
+ * Resolves a source Postgres database by add-on identity, attaches it
+ * to an app, and fetches the latest release version.
+ *
+ * Throws `NotAdvancedDatabaseError` (carrying the resolved add-on) if the
+ * database isn't an Advanced-tier database.
+ *
+ * If provided, `onAttached` fires once the attachment is created but before
+ * the release version fetch.
+ */
+export async function createAttachment(ctx, appIdentity, addonIdentity, body = {}, options = {}) {
+    const { onAttached, signal } = options;
+    signal?.throwIfAborted();
+    // Bind the signal so the resolve, create, and release-list requests abort in flight.
+    const platform = withSignal(ctx.platform, signal);
+    // Resolve scoped to the target app first. If the target app has no match, retry
+    // unscoped so attaching a database owned by a *different* app still resolves by
+    // its globally-unique name.
+    let addon;
+    try {
+        addon = await resolveAddonInternal(platform, addonIdentity, { addonService: getPostgresServiceName(), appIdentity });
+    }
+    catch (error) {
+        if (!(error instanceof NotFoundError)) {
+            throw error;
+        }
+        addon = await resolveAddonInternal(platform, addonIdentity, { addonService: getPostgresServiceName() });
+    }
+    if (!isAdvancedDatabase(addon)) {
+        throw new NotAdvancedDatabaseError(addon, `You can only attach Advanced-tier databases with postgresDatabase.createAttachment(). ${addon.name} isn't an Advanced-tier database.`);
+    }
+    let attachment;
+    try {
+        attachment = await platform.addOnAttachment.create({
+            ...body,
+            addon: addon.name,
+            app: appIdentity,
+        });
+    }
+    catch (error) {
+        if (error instanceof HerokuApiError && error.id === 'confirmation_required') {
+            throw new AddonConfirmationRequiredError(error.message);
+        }
+        throw error;
+    }
+    await onAttached?.(attachment);
+    signal?.throwIfAborted();
+    const releases = await platform
+        .withHeaders({ Range: 'version ..; max=1, order=desc' })
+        .release.list(appIdentity);
+    return { addon, attachment, releaseVersion: releases[0]?.version };
+}
+/**
+ * Resolves a Postgres database by add-on identity and destroys it.
+ *
+ * Resolution is scoped by `appIdentity` when given. If provided,
+ * `beforeDestroy` runs after resolution but before the delete request fires,
+ * so callers can confirm against the resolved add-on; an abort or throw in
+ * the hook prevents the delete. Delegates the delete (and optional
+ * deprovisioning poll when `wait` is set) to `addOn.destroyAndWait`.
+ */
+export async function destroy(ctx, addonIdentity, options = {}) {
+    const { appIdentity, beforeDestroy, force, onDeprovisioning, signal, wait, waitIntervalMs, } = options;
+    signal?.throwIfAborted();
+    // Bind the signal so the resolve request aborts in flight.
+    const platform = withSignal(ctx.platform, signal);
+    let addon;
+    try {
+        addon = await resolveAddonInternal(platform, addonIdentity, {
+            addonService: getPostgresServiceName(), appIdentity,
+        });
+    }
+    catch (error) {
+        // When scoped resolution misses, check whether the database exists under a
+        // different app so we can surface a targeted mismatch error instead of a
+        // bare not-found. Skip the probe for `::`-qualified identities: those name
+        // their app inline, so `resolveAddonInternal` ignores `appIdentity` and the
+        // unscoped retry would just repeat the same failing request.
+        if (appIdentity && !addonIdentity.includes('::') && error instanceof AddonNotFoundError) {
+            let elsewhere;
+            try {
+                elsewhere = await resolveAddonInternal(platform, addonIdentity, {
+                    addonService: getPostgresServiceName(),
+                });
+            }
+            catch (retryError) {
+                // Preserve aborts; an ambiguous/other failure here can't produce a
+                // clean mismatch message, so fall through to the original not-found.
+                if (signal?.aborted) {
+                    throw retryError;
+                }
+            }
+            // `appIdentity` may be an app name or UUID; compare against both so a
+            // UUID-scoped caller isn't always flagged as a mismatch (and doesn't get
+            // a raw UUID echoed back in the error message).
+            if (elsewhere && elsewhere.app.id !== appIdentity && elsewhere.app.name !== appIdentity) {
+                throw new AddonAppMismatchError(elsewhere, appIdentity);
+            }
+        }
+        throw error;
+    }
+    await beforeDestroy?.({ addon });
+    signal?.throwIfAborted();
+    // Resolution and beforeDestroy aborts already happened above; a failure here
+    // is the delete request (or wait poll) itself. Preserve aborts, but wrap other
+    // failures so callers get the resolved add-on (and thus tier) without
+    // re-resolving.
+    try {
+        const result = await destroyAndWait(ctx, addon.app.id, addon.id, {
+            force, onDeprovisioning, signal, wait, waitIntervalMs,
+        });
+        return { addon, result };
+    }
+    catch (error) {
+        if (signal?.aborted) {
+            throw error;
+        }
+        // A platform `confirmation_required` (e.g. destroying a database attached
+        // to other apps without `force`) is a distinct, recoverable condition —
+        // surface it as the typed error so callers can prompt and retry, matching
+        // `createAttachment`, rather than collapsing it into a generic failure.
+        if (error instanceof HerokuApiError && error.id === 'confirmation_required') {
+            throw new AddonConfirmationRequiredError(error.message);
+        }
+        throw new AddonDestroyFailedError(addon, error);
+    }
+}
 export const postgresDatabaseExtensions = extendResource('data', 'postgresDatabase', ctx => ({
+    createAttachment: (appIdentity, addonIdentity, body, options) => createAttachment(ctx, appIdentity, addonIdentity, body, options),
+    deleteAttachment: (appIdentity, attachmentName, options) => deleteAttachment(ctx, appIdentity, attachmentName, options),
+    destroy: (addonIdentity, options) => destroy(ctx, addonIdentity, options),
+    listAttachments: (addonIdentity, options) => listAttachments(ctx, addonIdentity, options),
     listCredentials: (appIdentity, addonIdentity, options) => listCredentials(ctx, appIdentity, addonIdentity, options),
 }));
+export { AddonAppMismatchError, AddonConfirmationRequiredError, AddonDestroyFailedError, AddonNotFoundError, } from '../platform/add-on/errors.js';
 export { parseAttachmentFactors, } from './internal/parse-attachment-factors.js';
-export { findLegacyDatabase, getPostgresServiceName, isAdvancedCredential, isAdvancedDatabase, isEssentialDatabase, isEssentialTier, isLegacyDatabase, isLegacyEssentialDatabase, isPostgresAddon, } from './internal/postgres-utils.js';
+export { findLegacyDatabase, getPostgresServiceName, isAdvancedCredential, isAdvancedDatabase, isEssentialDatabase, isEssentialTier, isLegacyDatabase, isLegacyEssentialDatabase, isPostgresAddon, NotAdvancedDatabaseError, } from './internal/postgres-utils.js';