@heroku/heroku-cli-util 10.1.3 → 10.3.0

package/README.md

@@ -2,14 +2,14 @@
 
 A set of helpful CLI utilities for Heroku and oclif-based Node.js CLIs. This
 package provides convenient wrappers and helpers for user interaction, output
-formatting, and test utilities.
+formatting, and color styling.
 
 ## Features
 
 - **User prompts and confirmations** (yes/no, input)
 - **Styled output** (headers, JSON, objects, tables)
 - **Wait indicators** for async operations
-- **Test helpers** for CLI output and environment setup
+- **Colors** for consistent, semantic CLI styling
 
 ## Installation
 
@@ -59,56 +59,97 @@ const name = await hux.prompt('What is your name?');
 const proceed = await hux.confirm('Continue?');
 ```
 
-### Test Helpers
+### Colors
 
 ```js
-import { testHelpers } from '@heroku/heroku-cli-util';
-
-testHelpers.initCliTest();
-
-testHelpers.setupStdoutStderr();
-// ...run your CLI code...
-const output = testHelpers.stdout();
-const errorOutput = testHelpers.stderr();
-testHelpers.restoreStdoutStderr();
-
-testHelpers.expectOutput(output, 'expected output');
-
-// Run a command (see docs for details)
-// await testHelpers.runCommand(MyCommand, ['arg1', 'arg2']);
+import { color } from '@heroku/heroku-cli-util';
+
+// App-related colors
+console.log(color.app('my-awesome-app'));        // Purple, bold with app icon
+console.log(color.pipeline('staging'));          // Purple
+console.log(color.space('production'));         // Blue, bold with space icon
+console.log(color.addon('heroku-postgresql'));   // Yellow, bold
+console.log(color.datastore('postgresql-123'));  // Yellow, bold with datastore icon
+
+// Status colors
+console.log(color.success('Deploy complete'));   // Green
+console.log(color.failure('Build failed'));      // Red
+console.log(color.warning('Deprecated feature')); // Orange
+
+// User/Team colors
+console.log(color.team('my-team'));              // Cyan, bold
+console.log(color.user('user@example.com'));     // Cyan
+
+// General purpose
+console.log(color.label('Name'));                // Bold
+console.log(color.info('Help text'));            // Teal
+console.log(color.command('heroku apps:list'));  // Command with prompt styling
 ```
 
+See the [COLORS.md](docs/COLORS.md) documentation for the complete color palette and usage guide.
+
 ### Types
 
+#### Error Classes
+
 ```js
-import { types } from '@heroku/heroku-cli-util';
+import { utils } from '@heroku/heroku-cli-util';
 
 // Error types
 try {
-  throw new types.errors.AmbiguousError([{ name: 'foo' }, { name: 'bar' }], 'addon');
+  throw new utils.errors.AmbiguousError([{ name: 'foo' }, { name: 'bar' }], 'addon');
 } catch (err) {
-  if (err instanceof types.errors.AmbiguousError) {
+  if (err instanceof utils.errors.AmbiguousError) {
     console.error('Ambiguous:', err.message);
   }
 }
 
 try {
-  throw new types.errors.NotFound();
+  throw new utils.errors.NotFound();
 } catch (err) {
-  if (err instanceof types.errors.NotFound) {
+  if (err instanceof utils.errors.NotFound) {
     console.error('Not found:', err.message);
   }
 }
+```
+
+#### PostgreSQL Types (TypeScript)
+
+Import PG types using the `pg` namespace:
+
+```typescript
+import type { pg } from '@heroku/heroku-cli-util';
+
+// Use the types
+const connection: pg.ConnectionDetails = {
+  database: 'mydb',
+  host: 'localhost',
+  password: 'pass',
+  pathname: '/mydb',
+  port: '5432',
+  url: 'postgres://...',
+  user: 'admin'
+};
+
+function processDatabase(details: pg.ConnectionDetailsWithAttachment) {
+  // ...
+}
+
+const addon: pg.AddOnWithRelatedData = { /* ... */ };
+const link: pg.Link = { /* ... */ };
+const tunnel: pg.TunnelConfig = { /* ... */ };
+```
+
+Alternatively, you can import types directly:
 
-// PG types (for TypeScript)
-/**
- * types.pg.ExtendedAddonAttachment
- * types.pg.AddOnWithRelatedData
- * types.pg.ConnectionDetails
- * types.pg.ConnectionDetailsWithAttachment
- * types.pg.Link
- * types.pg.TunnelConfig
- */
+```typescript
+import type { 
+  ConnectionDetails,
+  AddOnWithRelatedData,
+  ExtendedAddonAttachment,
+  Link,
+  TunnelConfig
+} from '@heroku/heroku-cli-util';
 ```
 
 ### Database and Utility Helpers

package/dist/errors/ambiguous.d.ts

@@ -1,10 +1,10 @@
-import type { ExtendedAddonAttachment } from '../types/pg/data-api.js';
+import type { ExtendedAddon, ExtendedAddonAttachment } from '../types/pg/platform-api.js';
 /**
  * This error is used internally to signal when the `AddonAttachmentResolver` cannot resolve
  * to a single attachment.
  */
 export declare class AmbiguousError extends Error {
-    readonly matches: ExtendedAddonAttachment[];
+    readonly matches: ExtendedAddon[] | ExtendedAddonAttachment[];
     readonly type: string;
     readonly body: {
         id: string;
@@ -12,5 +12,5 @@ export declare class AmbiguousError extends Error {
     };
     readonly message: string;
     readonly statusCode = 422;
-    constructor(matches: ExtendedAddonAttachment[], type: string);
+    constructor(matches: ExtendedAddon[] | ExtendedAddonAttachment[], type: string);
 }

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { APIClient } from '@heroku-cli/command';
+import type * as DataApiTypes from './types/pg/platform-api.js';
+import type * as TunnelTypes from './types/pg/tunnel.js';
 import { AmbiguousError } from './errors/ambiguous.js';
 import { NotFound } from './errors/not-found.js';
-import { AddOnWithRelatedData, ExtendedAddonAttachment, Link } from './types/pg/data-api.js';
-import { ConnectionDetails, ConnectionDetailsWithAttachment, TunnelConfig } from './types/pg/tunnel.js';
+import AddonResolver from './utils/addons/addon-resolver.js';
 import { getPsqlConfigs, sshTunnel } from './utils/pg/bastion.js';
 import { getConfigVarNameFromAttachment } from './utils/pg/config-vars.js';
 import DatabaseResolver from './utils/pg/databases.js';
@@ -14,17 +14,16 @@ import { styledJSON } from './ux/styled-json.js';
 import { styledObject } from './ux/styled-object.js';
 import { table } from './ux/table.js';
 import { wait } from './ux/wait.js';
-export declare const types: {
-    pg: {
-        AddOnWithRelatedData: AddOnWithRelatedData;
-        ConnectionDetails: ConnectionDetails;
-        ConnectionDetailsWithAttachment: ConnectionDetailsWithAttachment;
-        ExtendedAddonAttachment: ExtendedAddonAttachment;
-        Link: Link;
-        TunnelConfig: TunnelConfig;
-    };
-};
+export declare namespace pg {
+    type AddOnWithRelatedData = DataApiTypes.AddOnWithRelatedData;
+    type ExtendedAddon = DataApiTypes.ExtendedAddon;
+    type ExtendedAddonAttachment = DataApiTypes.ExtendedAddonAttachment;
+    type Link = DataApiTypes.Link;
+    type ConnectionDetails = TunnelTypes.ConnectionDetails;
+    type TunnelConfig = TunnelTypes.TunnelConfig;
+}
 export declare const utils: {
+    AddonResolver: typeof AddonResolver;
     errors: {
         AmbiguousError: typeof AmbiguousError;
         NotFound: typeof NotFound;
@@ -32,12 +31,15 @@ export declare const utils: {
     pg: {
         DatabaseResolver: typeof DatabaseResolver;
         PsqlService: typeof PsqlService;
-        fetcher: {
-            database(heroku: APIClient, appId: string, attachmentId?: string, namespace?: string): Promise<ConnectionDetailsWithAttachment>;
-        };
+        addonService: () => string;
         host: typeof getHost;
+        isAdvancedDatabase: (addon: DataApiTypes.ExtendedAddon | DataApiTypes.ExtendedAddonAttachment["addon"]) => boolean;
+        isAdvancedPrivateDatabase: (addon: DataApiTypes.ExtendedAddon | DataApiTypes.ExtendedAddonAttachment["addon"]) => boolean;
+        isEssentialDatabase: (addon: DataApiTypes.ExtendedAddon | DataApiTypes.ExtendedAddonAttachment["addon"]) => boolean;
+        isLegacyDatabase: (addon: DataApiTypes.ExtendedAddon | DataApiTypes.ExtendedAddonAttachment["addon"]) => boolean;
+        isLegacyEssentialDatabase: (addon: DataApiTypes.ExtendedAddon | DataApiTypes.ExtendedAddonAttachment["addon"]) => boolean;
+        isPostgresAddon: (addon: DataApiTypes.ExtendedAddon | DataApiTypes.ExtendedAddonAttachment["addon"]) => boolean;
         psql: {
-            exec(connectionDetails: ConnectionDetailsWithAttachment, query: string, psqlCmdArgs?: string[]): Promise<string>;
             getConfigVarNameFromAttachment: typeof getConfigVarNameFromAttachment;
             getPsqlConfigs: typeof getPsqlConfigs;
             sshTunnel: typeof sshTunnel;
@@ -53,3 +55,4 @@ export declare const hux: {
     table: typeof table;
     wait: typeof wait;
 };
+export * as color from './ux/colors.js';

package/dist/index.js

@@ -1,5 +1,7 @@
 import { AmbiguousError } from './errors/ambiguous.js';
 import { NotFound } from './errors/not-found.js';
+import AddonResolver from './utils/addons/addon-resolver.js';
+import { getAddonService, isAdvancedDatabase, isAdvancedPrivateDatabase, isEssentialDatabase, isLegacyDatabase, isLegacyEssentialDatabase, isPostgresAddon, } from './utils/addons/helpers.js';
 import { getPsqlConfigs, sshTunnel } from './utils/pg/bastion.js';
 import { getConfigVarNameFromAttachment } from './utils/pg/config-vars.js';
 import DatabaseResolver from './utils/pg/databases.js';
@@ -12,17 +14,8 @@ import { styledJSON } from './ux/styled-json.js';
 import { styledObject } from './ux/styled-object.js';
 import { table } from './ux/table.js';
 import { wait } from './ux/wait.js';
-export const types = {
-    pg: {
-        AddOnWithRelatedData: {},
-        ConnectionDetails: {},
-        ConnectionDetailsWithAttachment: {},
-        ExtendedAddonAttachment: {},
-        Link: {},
-        TunnelConfig: {},
-    },
-};
 export const utils = {
+    AddonResolver,
     errors: {
         AmbiguousError,
         NotFound, // This should be NotFoundError for consistency, but we're keeping it for backwards compatibility
@@ -30,18 +23,15 @@ export const utils = {
     pg: {
         DatabaseResolver,
         PsqlService,
-        fetcher: {
-            database(heroku, appId, attachmentId, namespace) {
-                const databaseResolver = new DatabaseResolver(heroku);
-                return databaseResolver.getDatabase(appId, attachmentId, namespace);
-            },
-        },
+        addonService: getAddonService,
         host: getHost,
+        isAdvancedDatabase,
+        isAdvancedPrivateDatabase,
+        isEssentialDatabase,
+        isLegacyDatabase,
+        isLegacyEssentialDatabase,
+        isPostgresAddon,
         psql: {
-            exec(connectionDetails, query, psqlCmdArgs = []) {
-                const psqlService = new PsqlService(connectionDetails);
-                return psqlService.execQuery(query, psqlCmdArgs);
-            },
             getConfigVarNameFromAttachment,
             getPsqlConfigs,
             sshTunnel,
@@ -57,3 +47,4 @@ export const hux = {
     table,
     wait,
 };
+export * as color from './ux/colors.js';

package/dist/types/pg/{data-api.d.ts → platform-api.d.ts}

@@ -31,6 +31,18 @@ type AddonAttachmentWithConfigVarsInclusion = {
 export type ExtendedAddonAttachment = {
     addon: AddonDescriptorWithPlanInclusion;
 } & AddonAttachmentWithConfigVarsInclusion;
+/**
+ * This is the modified type for the `AddOn` we use on these lib functions because all requests made to
+ * Platform API to get add-ons, either through the Add-on List endpoint or the add-on resolver action endpoint,
+ * include the header `Accept-Expansion: addon_service,plan`.
+ */
+export type ExtendedAddon = {
+    addon_service: DeepRequired<Heroku.AddOnService>;
+    plan: DeepRequired<Heroku.Plan>;
+} & DeepRequired<Heroku.AddOn>;
+/**
+ * The next two types need review and cleanup. They're not used anywhere in this codebase yet.
+ */
 export type AddOnWithRelatedData = {
     attachment_names?: string[];
     links?: Link[];

package/dist/types/pg/tunnel.d.ts

@@ -1,7 +1,8 @@
 import { Server } from 'node:net';
-import type { ExtendedAddonAttachment } from './data-api.js';
+import type { ExtendedAddonAttachment } from './platform-api.js';
 export type ConnectionDetails = {
     _tunnel?: Server;
+    attachment?: ExtendedAddonAttachment;
     database: string;
     host: string;
     password: string;
@@ -10,9 +11,6 @@ export type ConnectionDetails = {
     url: string;
     user: string;
 } & BastionConfig;
-export type ConnectionDetailsWithAttachment = {
-    attachment: ExtendedAddonAttachment;
-} & ConnectionDetails;
 export interface TunnelConfig {
     dstHost: string;
     dstPort: number;

package/dist/utils/addons/addon-resolver.d.ts

@@ -0,0 +1,8 @@
+import type { APIClient } from '@heroku-cli/command';
+import type { ExtendedAddon } from '../../types/pg/platform-api.js';
+export default class AddonResolver {
+    private readonly heroku;
+    private readonly addonHeaders;
+    constructor(heroku: APIClient);
+    resolve(addon: string, app?: string, addonService?: string): Promise<ExtendedAddon>;
+}

package/dist/utils/addons/addon-resolver.js

@@ -0,0 +1,26 @@
+import { AmbiguousError } from '../../errors/ambiguous.js';
+export default class AddonResolver {
+    heroku;
+    addonHeaders = {
+        Accept: 'application/vnd.heroku+json; version=3.sdk',
+        'Accept-Expansion': 'addon_service,plan',
+    };
+    constructor(heroku) {
+        this.heroku = heroku;
+    }
+    async resolve(addon, app, addonService) {
+        const [appPart, addonPart] = addon.match(/^(.+)::(.+)$/)?.slice(1) ?? [app, addon];
+        const { body: addons } = await this.heroku.post('/actions/addons/resolve', {
+            body: {
+                addon: addonPart,
+                addon_service: addonService,
+                app: appPart,
+            },
+            headers: this.addonHeaders,
+        });
+        if (addons.length === 1) {
+            return addons[0];
+        }
+        throw new AmbiguousError(addons, 'addon');
+    }
+}

package/dist/utils/addons/{resolve.d.ts → attachment-resolver.d.ts}

@@ -1,5 +1,5 @@
 import type { APIClient } from '@heroku-cli/command';
-import type { ExtendedAddonAttachment } from '../../types/pg/data-api.js';
+import type { ExtendedAddonAttachment } from '../../types/pg/platform-api.js';
 export interface AddonAttachmentResolverOptions {
     addonService?: string;
     namespace?: string;

package/dist/utils/addons/helpers.d.ts

@@ -0,0 +1,8 @@
+import { ExtendedAddon, ExtendedAddonAttachment } from '../../types/pg/platform-api.js';
+export declare const getAddonService: () => string;
+export declare const isPostgresAddon: (addon: ExtendedAddon | ExtendedAddonAttachment["addon"]) => boolean;
+export declare const isAdvancedDatabase: (addon: ExtendedAddon | ExtendedAddonAttachment["addon"]) => boolean;
+export declare const isAdvancedPrivateDatabase: (addon: ExtendedAddon | ExtendedAddonAttachment["addon"]) => boolean;
+export declare const isLegacyDatabase: (addon: ExtendedAddon | ExtendedAddonAttachment["addon"]) => boolean;
+export declare const isLegacyEssentialDatabase: (addon: ExtendedAddon | ExtendedAddonAttachment["addon"]) => boolean;
+export declare const isEssentialDatabase: (addon: ExtendedAddon | ExtendedAddonAttachment["addon"]) => boolean;

package/dist/utils/addons/helpers.js

@@ -0,0 +1,7 @@
+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 isAdvancedPrivateDatabase = (addon) => isAdvancedDatabase(addon) && /(private|shield)/.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');

package/dist/utils/pg/bastion.d.ts

@@ -1,6 +1,6 @@
 import type { APIClient } from '@heroku-cli/command';
 import { Server } from 'node:net';
-import { ExtendedAddonAttachment } from '../../types/pg/data-api.js';
+import { ExtendedAddonAttachment } from '../../types/pg/platform-api.js';
 import { BastionConfig, ConnectionDetails, TunnelConfig } from '../../types/pg/tunnel.js';
 /**
  * Determines whether the attachment belongs to an add-on installed onto a non-shield Private Space.

package/dist/utils/pg/config-vars.d.ts

@@ -1,6 +1,6 @@
 import type { HTTP } from '@heroku/http-call';
 import type { APIClient } from '@heroku-cli/command';
-import type { ExtendedAddonAttachment } from '../../types/pg/data-api.js';
+import type { ExtendedAddonAttachment } from '../../types/pg/platform-api.js';
 /**
  * Cache of app config vars.
  */

package/dist/utils/pg/config-vars.js

@@ -1,4 +1,4 @@
-import { color } from '@heroku-cli/color';
+import * as color from '../../ux/colors.js';
 /**
  * Cache of app config vars.
  */
@@ -49,8 +49,8 @@ export function getConfigVarNameFromAttachment(attachment, config = {}) {
         .filter(cvn => config[cvn]?.startsWith('postgres://'));
     if (connStringConfigVarNames.length === 0) {
         throw new Error(`No config vars found for ${attachment.name}; perhaps they were removed as a side effect of`
-            + ` ${color.cmd('heroku rollback')}? Use ${color.cmd('heroku addons:attach')} to create a new attachment and `
-            + `then ${color.cmd('heroku addons:detach')} to remove the current attachment.`);
+            + ` ${color.command('heroku rollback')}? Use ${color.command('heroku addons:attach')} to create a new attachment and `
+            + `then ${color.command('heroku addons:detach')} to remove the current attachment.`);
     }
     // Generate the default config var name and return it if it contains a database URL connection string.
     const configVarName = `${attachment.name}_URL`;

package/dist/utils/pg/databases.d.ts

@@ -1,6 +1,6 @@
 import { APIClient } from '@heroku-cli/command';
-import type { ExtendedAddonAttachment } from '../../types/pg/data-api.js';
-import type { ConnectionDetails, ConnectionDetailsWithAttachment } from '../../types/pg/tunnel.js';
+import type { ExtendedAddon, ExtendedAddonAttachment } from '../../types/pg/platform-api.js';
+import type { ConnectionDetails } from '../../types/pg/tunnel.js';
 import { fetchBastionConfig } from './bastion.js';
 import { getConfig } from './config-vars.js';
 export default class DatabaseResolver {
@@ -8,8 +8,34 @@ export default class DatabaseResolver {
     private readonly getConfigFn;
     private readonly fetchBastionConfigFn;
     private readonly addonAttachmentResolver;
+    private readonly addonHeaders;
     private readonly attachmentHeaders;
     constructor(heroku: APIClient, getConfigFn?: typeof getConfig, fetchBastionConfigFn?: typeof fetchBastionConfig);
+    /**
+     * Parses a PostgreSQL connection string (or a local database name) into a ConnectionDetails object.
+     *
+     * @param connStringOrDbName - PostgreSQL connection string or local database name
+     * @returns Connection details object with parsed connection information
+     */
+    static parsePostgresConnectionString(connStringOrDbName: string): ConnectionDetails;
+    /**
+     * Return all Heroku Postgres databases on the Legacy tiers for a given app.
+     *
+     * @param app - The name of the app to get the databases for
+     * @returns Promise resolving to all Heroku Postgres databases
+     * @throws {Error} When no legacy database add-on exists on the app
+     */
+    getAllLegacyDatabases(app: string): Promise<Array<{
+        attachment_names?: string[];
+    } & ExtendedAddonAttachment['addon']>>;
+    /**
+     * Resolves an arbitrary legacy database add-on based on the provided app name.
+     *
+     * @param app - The name of the app to get the arbitrary legacy database for
+     * @returns Promise resolving to the arbitrary legacy database add-on
+     * @throws {Error} When no legacy database add-on exists on the app
+     */
+    getArbitraryLegacyDB(app: string): Promise<ExtendedAddon>;
     /**
      * Resolves a database attachment based on the provided database identifier
      * (attachment name, id, or config var name) and namespace (credential).
@@ -22,6 +48,14 @@ export default class DatabaseResolver {
      * @throws {AmbiguousError} When multiple matching attachments are found
      */
     getAttachment(appId: string, attachmentId?: string, namespace?: string): Promise<ExtendedAddonAttachment>;
+    /**
+     * Returns the connection details for a database attachment according to the app config vars.
+     *
+     * @param attachment - The attachment to get the connection details for
+     * @param config - The record of app config vars with their values
+     * @returns Connection details with attachment information
+     */
+    getConnectionDetails(attachment: ExtendedAddonAttachment, config?: Record<string, string>): ConnectionDetails;
     /**
      * Returns the connection details for a database attachment resolved through the identifiers passed as
      * arguments: appId, attachmentId and namespace (credential).
@@ -31,14 +65,14 @@ export default class DatabaseResolver {
      * @param namespace - Optional namespace/credential for the attachment
      * @returns Promise resolving to connection details with attachment information
      */
-    getDatabase(appId: string, attachmentId?: string, namespace?: string): Promise<ConnectionDetailsWithAttachment>;
+    getDatabase(appId: string, attachmentId?: string, namespace?: string): Promise<ConnectionDetails>;
     /**
-     * Parses a PostgreSQL connection string (or a local database name) into a ConnectionDetails object.
+     * Helper function that attempts to find all Heroku Postgres attachments on a given app.
      *
-     * @param connStringOrDbName - PostgreSQL connection string or local database name
-     * @returns Connection details object with parsed connection information
+     * @param app - The name of the app to get the attachments for
+     * @returns Promise resolving to an array of all Heroku Postgres attachments on the app
      */
-    static parsePostgresConnectionString(connStringOrDbName: string): ConnectionDetails;
+    private allLegacyDatabaseAttachments;
     /**
      * Fetches all Heroku PostgreSQL add-on attachments for a given app.
      *
@@ -51,15 +85,29 @@ export default class DatabaseResolver {
      */
     private allPostgresAttachments;
     /**
-     * Returns the connection details for a database attachment according to the app config vars.
+     * Helper function that groups Heroku Postgres attachments by addon.
      *
-     * @param attachment - The attachment to get the connection details for
-     * @param config - The record of app config vars with their values
-     * @returns Connection details with attachment information
+     * @param attachments - The attachments to group by addon
+     * @returns A record of addon IDs with their attachment names
+     */
+    private getAttachmentNamesByAddon;
+    /**
+     * Helper function that attempts to find a single addon attachment matching the given database identifier
+     * by comparing the identifier to the config var names of all attachments on the app
+     * (attachment name, id, or config var name).
+     *
+     * This is used internally by the `getAttachment` function to handle the lookup of addon attachments.
+     * It returns either an array with a single match or an empty array if no matches are found.
+     *
+     * @param attachments - Array of attachments for the specified app ID
+     * @param appId - The ID of the app to search for attachments
+     * @param attachmentId - The database identifier to match
+     * @returns Promise resolving to either a single match or no matches
      */
-    getConnectionDetails(attachment: ExtendedAddonAttachment, config?: Record<string, string>): ConnectionDetailsWithAttachment;
+    private getAttachmentsViaConfigVarNames;
     /**
      * Helper function that attempts to find a single addon attachment matching the given database identifier
+     * via the add-on attachments resolver
      * (attachment name, id, or config var name).
      *
      * This is used internally by the `getAttachment` function to handle the lookup of addon attachments.
@@ -72,5 +120,5 @@ export default class DatabaseResolver {
      * @param namespace - Optional namespace/credential filter
      * @returns Promise resolving to either a single match, multiple matches with error, or no matches with error
      */
-    private matchesHelper;
+    private getAttachmentsViaResolver;
 }