@heroku/sdk 0.8.0 → 0.8.1

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

@@ -0,0 +1,10 @@
+import type { AddOn } from '@heroku/types/3.sdk';
+import { ResourceCtx } from '../../../core/extend-resource.js';
+/**
+ * Returns an arbitrary legacy database add-on based on the provided app name.
+ */
+export declare function getArbitraryLegacyDB(ctx: Pick<ResourceCtx, 'platform'>, appIdentity: string): Promise<AddOn>;
+export declare const getAddonService: () => string;
+export declare const isPostgresAddon: (addon: AddOn) => boolean;
+export declare const isAdvancedDatabase: (addon: AddOn) => boolean;
+export declare const isLegacyDatabase: (addon: AddOn) => boolean;

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

@@ -0,0 +1,17 @@
+import createDebug from 'debug';
+const debug = createDebug('postgres-utils');
+/**
+ * Returns an arbitrary legacy database add-on based on the provided app name.
+ */
+export async function getArbitraryLegacyDB(ctx, appIdentity) {
+    debug(`fetching arbitrary legacy database on ${appIdentity}`);
+    const addons = await ctx.platform.addOn.listByApp(appIdentity);
+    const addon = addons.find(a => a.app.name === appIdentity && isLegacyDatabase(a));
+    if (!addon)
+        throw new Error(`No Heroku Postgres legacy database on ${appIdentity}`);
+    return addon;
+}
+export const getAddonService = () => process.env.HEROKU_POSTGRESQL_ADDON_NAME || process.env.HEROKU_DATA_SERVICE || 'heroku-postgresql';
+export const isPostgresAddon = (addon) => addon.plan?.name?.split(':', 2)[0] === getAddonService();
+export const isAdvancedDatabase = (addon) => isPostgresAddon(addon) && /^(advanced|performance)/.test(addon.plan?.name?.split(':', 2)[1] ?? '');
+export const isLegacyDatabase = (addon) => isPostgresAddon(addon) && !isAdvancedDatabase(addon);

package/dist/resources/data/internal/resolve-pg-database.d.ts

@@ -1,8 +1,13 @@
 import type { ResourceCtx } from '../../../core/extend-resource.js';
 import type { ResolveAddonAttachmentOptions, ResolvedAddOnAttachment } from '../../platform/add-on-attachment/resolve.js';
 export type ResolvedPgDatabase = ResolvedAddOnAttachment['addon'];
+export type ResolvedPgDatabaseWithAttachment = {
+    addon: ResolvedPgDatabase;
+    attachment: ResolvedAddOnAttachment;
+};
 export type ResolvePgDatabaseOptions = ResolveAddonAttachmentOptions & {
     appIdentity?: string;
+    includeAttachment?: boolean;
     input?: string;
 };
 /**
@@ -36,4 +41,7 @@ export type ResolvePgDatabaseOptions = ResolveAddonAttachmentOptions & {
  * from the underlying resolver. Throws if no input is given and no `appIdentity`
  * is available to default the attachment lookup to.
  */
+export declare function resolvePgDatabase(ctx: Pick<ResourceCtx, 'platform'>, options: ResolvePgDatabaseOptions & {
+    includeAttachment: true;
+}): Promise<ResolvedPgDatabaseWithAttachment>;
 export declare function resolvePgDatabase(ctx: Pick<ResourceCtx, 'platform'>, options?: ResolvePgDatabaseOptions): Promise<ResolvedPgDatabase>;

package/dist/resources/data/internal/resolve-pg-database.js

@@ -1,41 +1,11 @@
 import createDebug from 'debug';
 import { AddonAttachmentAmbiguousError, resolveAddonAttachment } from '../../platform/add-on-attachment/resolve.js';
+import { getAddonService } from './postgres-utils.js';
 const debug = createDebug('heroku:sdk:resources:database');
 const DEFAULT_PG_ATTACHMENT = 'DATABASE_URL';
-const PG_ADDON_SERVICE = process.env.HEROKU_POSTGRESQL_ADDON_NAME ?? process.env.HEROKU_DATA_SERVICE ?? 'heroku-postgresql';
-/**
- * Resolve a Heroku Postgres database add-on from an attachment identity.
- *
- * `input` selects the attachment as follows:
- *   - omitted → the `DATABASE_URL` attachment on `appIdentity`.
- *   - `parent-app::attachment-or-config-var` (e.g. `my-app::DATABASE_URL`)
- *     → an attachment or config var on `parent-app`.
- *   - `parent-app::branch-name` (e.g. `my-app::my-branch`) → branch add-on
- *     name on `parent-app`.
- *   - Both `::` forms are handled the same way here: we split on the first
- *     `::` ourselves and send `app`/`addon` as separate fields, which
- *     works for either shape.
- *   - any other string (attachment name, config var, UUID, or
- *     globally-unique add-on name) → routed through `resolveAddonAttachment`.
- *
- * This function only uses the attachment resolver. To resolve a database
- * through the add-on resolve endpoint, call `resolveAddon` directly.
- *
- * The returned add-on is the identity nested on the attachment (`id`,
- * `name`, `app`, and the plan stub), not a full `ResolvedAddOn`. To get
- * that shape, call `resolveAddon` with the returned add-on's `id`.
- *
- * If the resolver finds multiple matches that all point at the same add-on
- * (same `addon.id`/attachment `app.id`) and whose own `_URL` config var
- * resolves to the same value on the app, they're treated as equivalent
- * (e.g. the same database attached under two names) rather than ambiguous.
- *
- * Throws `AddonAttachmentNotFoundError` (or `AddonAttachmentAmbiguousError`)
- * from the underlying resolver. Throws if no input is given and no `appIdentity`
- * is available to default the attachment lookup to.
- */
+const PG_ADDON_SERVICE = getAddonService();
 export async function resolvePgDatabase(ctx, options = {}) {
-    const { appIdentity, input, ...rest } = options;
+    const { appIdentity, includeAttachment, input, ...rest } = options;
     if (!input && !appIdentity) {
         throw new Error('resolvePgDatabase requires either input or appIdentity to default to DATABASE_URL.');
     }
@@ -44,22 +14,22 @@ export async function resolvePgDatabase(ctx, options = {}) {
         ? parseBranchReference(databaseReference, appIdentity)
         : { addon: databaseReference, app: appIdentity };
     debug('resolve input=%s addon=%s app=%s', input ?? '<default>', addon, app ?? '<global>');
+    let attachment;
     try {
-        const attachment = await resolveAddonAttachment(ctx, app, addon, { ...rest, addonService: PG_ADDON_SERVICE });
-        return attachment.addon;
+        attachment = await resolveAddonAttachment(ctx, app, addon, { ...rest, addonService: PG_ADDON_SERVICE });
     }
     catch (error) {
-        if (error instanceof AddonAttachmentAmbiguousError) {
-            const equivalent = collapseIfEquivalent(error.matches);
-            if (equivalent) {
-                const config = await ctx.platform.configVar.infoForApp(equivalent[0].app.name);
-                if (allMatchSameUrl(equivalent, config)) {
-                    return equivalent[0].addon;
-                }
-            }
-        }
-        throw error;
+        if (!(error instanceof AddonAttachmentAmbiguousError))
+            throw error;
+        const equivalent = collapseIfEquivalent(error.matches);
+        if (!equivalent)
+            throw error;
+        const config = await ctx.platform.configVar.infoForApp(equivalent[0].app.name);
+        if (!allMatchSameUrl(equivalent, config))
+            throw error;
+        attachment = equivalent[0];
     }
+    return includeAttachment ? { addon: attachment.addon, attachment } : attachment.addon;
 }
 /**
  * Narrows ambiguous matches to a same-add-on group worth comparing by

package/dist/resources/data/transfer-schedule.d.ts

@@ -9,11 +9,11 @@ export type TransferSchedule = {
 export type TransferScheduleOptions = {
     signal?: AbortSignal;
 };
-export declare function list(ctx: Pick<ResourceCtx, 'data' | 'platform'>, appIdentity: string, addonIdentity?: string, options?: TransferScheduleOptions): Promise<TransferSchedule[]>;
+export declare function list(ctx: Pick<ResourceCtx, 'data' | 'platform'>, appIdentity: string, options?: TransferScheduleOptions): Promise<TransferSchedule[]>;
 export declare function create(ctx: Pick<ResourceCtx, 'data' | 'platform'>, appIdentity: string, addonIdentity: string | undefined, body: TransferScheduleCreateOpts, options?: TransferScheduleOptions): Promise<TransferScheduleCreateResult>;
 export declare function del(ctx: Pick<ResourceCtx, 'data' | 'platform'>, appIdentity: string, addonIdentity: string | undefined, scheduleId: string, options?: TransferScheduleOptions): Promise<TransferScheduleDeleteResult>;
 export declare const transferScheduleExtensions: import("../../core/extend-resource.js").ResourceExtension<"data", "transferSchedule", {
     create: (appIdentity: string, addonIdentity: string | undefined, body: TransferScheduleCreateOpts, options?: TransferScheduleOptions) => Promise<TransferScheduleCreateResult>;
     delete: (appIdentity: string, addonIdentity: string | undefined, scheduleId: string, options?: TransferScheduleOptions) => Promise<TransferScheduleDeleteResult>;
-    list: (appIdentity: string, addonIdentity?: string, options?: TransferScheduleOptions) => Promise<TransferSchedule[]>;
+    list: (appIdentity: string, options?: TransferScheduleOptions) => Promise<TransferSchedule[]>;
 }>;

package/dist/resources/data/transfer-schedule.js

@@ -1,14 +1,23 @@
 import { extendResource } from '../../core/extend-resource.js';
+import { getArbitraryLegacyDB } from './internal/postgres-utils.js';
 import { resolvePgDatabase } from './internal/resolve-pg-database.js';
-export async function list(ctx, appIdentity, addonIdentity, options = {}) {
+export async function list(ctx, appIdentity, options = {}) {
     options.signal?.throwIfAborted();
-    const addon = await resolvePgDatabase(ctx, { appIdentity, input: addonIdentity, ...options });
+    // Schedules are app-scoped, so any legacy DB ID unlocks the app's list.
+    const addon = await getArbitraryLegacyDB(ctx, appIdentity);
     return ctx.data.transferSchedule.list(addon.id);
 }
 export async function create(ctx, appIdentity, addonIdentity, body, options = {}) {
     options.signal?.throwIfAborted();
-    const addon = await resolvePgDatabase(ctx, { appIdentity, input: addonIdentity, ...options });
-    return ctx.data.transferSchedule.create(addon.id, body);
+    const { addon, attachment } = await resolvePgDatabase(ctx, {
+        appIdentity, includeAttachment: true, input: addonIdentity, ...options,
+    });
+    let requestBody = body;
+    if (!requestBody.schedule_name) {
+        // eslint-disable-next-line camelcase
+        requestBody = { ...body, schedule_name: `${attachment.name}_URL` };
+    }
+    return ctx.data.transferSchedule.create(addon.id, requestBody);
 }
 export async function del(ctx, appIdentity, addonIdentity, scheduleId, options = {}) {
     options.signal?.throwIfAborted();
@@ -18,5 +27,5 @@ export async function del(ctx, appIdentity, addonIdentity, scheduleId, options =
 export const transferScheduleExtensions = extendResource('data', 'transferSchedule', ctx => ({
     create: (appIdentity, addonIdentity, body, options) => create(ctx, appIdentity, addonIdentity, body, options),
     delete: (appIdentity, addonIdentity, scheduleId, options) => del(ctx, appIdentity, addonIdentity, scheduleId, options),
-    list: (appIdentity, addonIdentity, options) => list(ctx, appIdentity, addonIdentity, options),
+    list: (appIdentity, options) => list(ctx, appIdentity, options),
 }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heroku/sdk",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Heroku SDK",
   "author": "Heroku",
   "type": "module",