@heroku/heroku-cli-util 10.1.3-beta.0 → 10.2.0

package/README.md

@@ -80,35 +80,66 @@ testHelpers.expectOutput(output, 'expected output');
 
 ### 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;

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,

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,28 @@
+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];
+        console.log('appPart', appPart);
+        console.log('addonPart', addonPart);
+        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/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;
 }

package/dist/utils/pg/databases.js

@@ -2,7 +2,8 @@ import { color } from '@heroku-cli/color';
 import { HerokuAPIError } from '@heroku-cli/command/lib/api-client.js';
 import debug from 'debug';
 import { AmbiguousError } from '../../errors/ambiguous.js';
-import AddonAttachmentResolver from '../addons/resolve.js';
+import AddonAttachmentResolver from '../addons/attachment-resolver.js';
+import { getAddonService, isLegacyDatabase } from '../addons/helpers.js';
 import { bastionKeyPlan, fetchBastionConfig, getBastionConfig } from './bastion.js';
 import { getConfig, getConfigVarName, getConfigVarNameFromAttachment } from './config-vars.js';
 const pgDebug = debug('pg');
@@ -11,6 +12,10 @@ export default class DatabaseResolver {
     getConfigFn;
     fetchBastionConfigFn;
     addonAttachmentResolver;
+    addonHeaders = {
+        Accept: 'application/vnd.heroku+json; version=3.sdk',
+        'Accept-Expansion': 'addon_service,plan',
+    };
     attachmentHeaders = {
         Accept: 'application/vnd.heroku+json; version=3.sdk',
         'Accept-Inclusion': 'addon:plan,config_vars',
@@ -21,6 +26,64 @@ export default class DatabaseResolver {
         this.fetchBastionConfigFn = fetchBastionConfigFn;
         this.addonAttachmentResolver = new AddonAttachmentResolver(this.heroku);
     }
+    /**
+     * 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) {
+        const dbPath = /:\/\//.test(connStringOrDbName) ? connStringOrDbName : `postgres:///${connStringOrDbName}`;
+        const url = new URL(dbPath);
+        const { hostname, password, pathname, port, username } = url;
+        return {
+            database: pathname.slice(1), // remove the leading slash from the pathname
+            host: hostname,
+            password,
+            pathname,
+            port: port || process.env.PGPORT || (hostname && '5432'),
+            url: dbPath,
+            user: username,
+        };
+    }
+    /**
+     * 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
+     */
+    async getAllLegacyDatabases(app) {
+        pgDebug(`fetching all legacy databases on ${app}`);
+        const allAttachments = await this.allLegacyDatabaseAttachments(app);
+        const addons = [];
+        for (const attachment of allAttachments) {
+            if (!addons.some(a => a.id === attachment.addon.id)) {
+                addons.push(attachment.addon);
+            }
+        }
+        const attachmentNamesByAddon = this.getAttachmentNamesByAddon(allAttachments);
+        for (const addon of addons) {
+            // eslint-disable-next-line camelcase
+            addon.attachment_names = attachmentNamesByAddon[addon.id];
+        }
+        return addons;
+    }
+    /**
+     * 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
+     */
+    async getArbitraryLegacyDB(app) {
+        pgDebug(`fetching arbitrary legacy database on ${app}`);
+        const { body: addons } = await this.heroku.get(`/apps/${app}/addons`, { headers: this.addonHeaders });
+        const addon = addons.find(a => a.app.name === app && isLegacyDatabase(a));
+        if (!addon)
+            throw new Error(`No Heroku Postgres legacy database on ${app}`);
+        return addon;
+    }
     /**
      * Resolves a database attachment based on the provided database identifier
      * (attachment name, id, or config var name) and namespace (credential).
@@ -39,20 +102,24 @@ export default class DatabaseResolver {
             appId = appConfigMatch[1];
             attachmentId = appConfigMatch[2];
         }
-        const { error, matches } = await this.matchesHelper(appId, attachmentId, namespace);
+        let { error, matches } = await this.getAttachmentsViaResolver(appId, attachmentId, namespace);
         // happy path where the resolver matches just one
         if (matches && matches.length === 1) {
             return matches[0];
         }
-        // handle the case where the resolver didn't find any matches for the given database and show valid options.
+        // handle the case where the resolver didn't find any matches for the given database.
         if (!matches) {
             const attachments = await this.allPostgresAttachments(appId);
             if (attachments.length === 0) {
                 throw new Error(`${color.app(appId)} has no databases`);
             }
-            else {
+            // attempt to find a match using config var names
+            matches = await this.getAttachmentsViaConfigVarNames(attachments, appId, attachmentId);
+            if (matches.length === 0) {
+                const databaseName = attachmentId.endsWith('_URL') ? attachmentId.slice(0, -4) : attachmentId;
                 const validOptions = attachments.map(attachment => getConfigVarName(attachment.config_vars));
-                throw new Error(`Unknown database: ${attachmentId}. Valid options are: ${validOptions.join(', ')}`);
+                const validOptionsString = validOptions.map(option => option.endsWith('_URL') ? option.slice(0, -4) : option).join(', ');
+                throw new Error(`Unknown database: ${databaseName}. Valid options are: ${validOptionsString}`);
             }
         }
         // handle the case where the resolver found multiple matches for the given database.
@@ -66,6 +133,36 @@ export default class DatabaseResolver {
         }
         throw error;
     }
+    /**
+     * 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, config = {}) {
+        const connStringVar = getConfigVarNameFromAttachment(attachment, config);
+        // build the default payload for non-bastion dbs
+        pgDebug(`Using "${connStringVar}" to connect to your database…`);
+        const conn = DatabaseResolver.parsePostgresConnectionString(config[connStringVar]);
+        const payload = {
+            attachment,
+            database: conn.database,
+            host: conn.host,
+            password: conn.password,
+            pathname: conn.pathname,
+            port: conn.port,
+            url: conn.url,
+            user: conn.user,
+        };
+        // This handles injection of bastion creds into the payload if they exist as config vars (Shield-tier databases).
+        const baseName = connStringVar.slice(0, -4);
+        const bastion = getBastionConfig(config, baseName);
+        if (bastion) {
+            Object.assign(payload, bastion);
+        }
+        return payload;
+    }
     /**
      * Returns the connection details for a database attachment resolved through the identifiers passed as
      * arguments: appId, attachmentId and namespace (credential).
@@ -87,25 +184,14 @@ export default class DatabaseResolver {
         return database;
     }
     /**
-     * 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
      */
-    // eslint-disable-next-line perfectionist/sort-classes
-    static parsePostgresConnectionString(connStringOrDbName) {
-        const dbPath = /:\/\//.test(connStringOrDbName) ? connStringOrDbName : `postgres:///${connStringOrDbName}`;
-        const url = new URL(dbPath);
-        const { hostname, password, pathname, port, username } = url;
-        return {
-            database: pathname.slice(1), // remove the leading slash from the pathname
-            host: hostname,
-            password,
-            pathname,
-            port: port || process.env.PGPORT || (hostname && '5432'),
-            url: dbPath,
-            user: username,
-        };
+    async allLegacyDatabaseAttachments(app) {
+        const { body: attachments } = await this.heroku.get(`/apps/${app}/addon-attachments`, { headers: this.attachmentHeaders });
+        return attachments.filter(a => isLegacyDatabase(a.addon));
     }
     /**
      * Fetches all Heroku PostgreSQL add-on attachments for a given app.
@@ -118,45 +204,45 @@ export default class DatabaseResolver {
      * @returns Promise resolving to array of PostgreSQL add-on attachments
      */
     async allPostgresAttachments(appId) {
-        const addonService = process.env.HEROKU_POSTGRESQL_ADDON_NAME || 'heroku-postgresql';
         const { body: attachments } = await this.heroku.get(`/apps/${appId}/addon-attachments`, {
             headers: this.attachmentHeaders,
         });
-        return attachments.filter(a => a.addon.plan.name.split(':', 2)[0] === addonService);
+        return attachments.filter(a => a.addon.plan.name.split(':', 2)[0] === getAddonService());
     }
     /**
-     * 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
      */
-    // eslint-disable-next-line perfectionist/sort-classes
-    getConnectionDetails(attachment, config = {}) {
-        const connStringVar = getConfigVarNameFromAttachment(attachment, config);
-        // build the default payload for non-bastion dbs
-        pgDebug(`Using "${connStringVar}" to connect to your database…`);
-        const conn = DatabaseResolver.parsePostgresConnectionString(config[connStringVar]);
-        const payload = {
-            attachment,
-            database: conn.database,
-            host: conn.host,
-            password: conn.password,
-            pathname: conn.pathname,
-            port: conn.port,
-            url: conn.url,
-            user: conn.user,
-        };
-        // This handles injection of bastion creds into the payload if they exist as config vars (Shield-tier databases).
-        const baseName = connStringVar.slice(0, -4);
-        const bastion = getBastionConfig(config, baseName);
-        if (bastion) {
-            Object.assign(payload, bastion);
+    getAttachmentNamesByAddon(attachments) {
+        const addons = {};
+        for (const attachment of attachments) {
+            addons[attachment.addon.id] = [...(addons[attachment.addon.id] || []), attachment.name];
         }
-        return payload;
+        return addons;
+    }
+    /**
+     * 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
+     */
+    async getAttachmentsViaConfigVarNames(attachments, appId, attachmentId) {
+        const targetConfigVarName = attachmentId.endsWith('_URL') ? attachmentId : `${attachmentId}_URL`;
+        const config = await this.getConfigFn(this.heroku, appId);
+        return attachments.filter(attachment => config[targetConfigVarName] && config[targetConfigVarName] === config[getConfigVarName(attachment.config_vars)]);
     }
     /**
      * 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.
@@ -169,9 +255,9 @@ 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
      */
-    async matchesHelper(appId, attachmentId, namespace) {
+    async getAttachmentsViaResolver(appId, attachmentId, namespace) {
         debug(`fetching ${attachmentId} on ${appId}`);
-        const addonService = process.env.HEROKU_POSTGRESQL_ADDON_NAME || 'heroku-postgresql';
+        const addonService = getAddonService();
         debug(`addon service: ${addonService}`);
         try {
             const attached = await this.addonAttachmentResolver.resolve(appId, attachmentId, { addonService, namespace });

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

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
 import { Server } from 'node:net';
-import { ConnectionDetails, TunnelConfig } from '../../types/pg/tunnel.js';
+import type { ConnectionDetails, TunnelConfig } from '../../types/pg/tunnel.js';
 import { getPsqlConfigs, sshTunnel } from './bastion.js';
 /**
  * A small wrapper around tunnel-ssh so that other code doesn't have to worry about whether there is or is not a tunnel.
@@ -43,6 +43,16 @@ export default class PsqlService {
     private readonly spawnFn;
     private readonly tunnelFn;
     constructor(connectionDetails: ConnectionDetails, getPsqlConfigsFn?: typeof getPsqlConfigs, spawnFn?: typeof spawn, tunnelFn?: typeof sshTunnel);
+    /**
+     * Executes a file containing SQL commands using the instance's database connection details.
+     * It uses the `getPsqlConfigs` function to get the configuration for the database and the tunnel,
+     * and then calls the `runWithTunnel` function to execute the file.
+     *
+     * @param file - The path to the SQL file to execute
+     * @param psqlCmdArgs - Additional command-line arguments for psql (default: [])
+     * @returns Promise that resolves to the query result as a string
+     */
+    execFile(file: string, psqlCmdArgs?: string[]): Promise<string>;
     /**
      * Executes a PostgreSQL query using the instance's database connection details.
      * It uses the `getPsqlConfigs` function to get the configuration for the database and the tunnel,
@@ -53,6 +63,29 @@ export default class PsqlService {
      * @returns Promise that resolves to the query result as a string
      */
     execQuery(query: string, psqlCmdArgs?: string[]): Promise<string>;
+    /**
+     * Fetches the PostgreSQL version from the database by executing the `SHOW server_version` query.
+     *
+     * @returns Promise that resolves to the PostgreSQL version as a string (or undefined).
+     */
+    fetchVersion(): Promise<string | undefined>;
+    /**
+     * Executes a PostgreSQL interactive session using the instance's database connection details.
+     * It uses the `getPsqlConfigs` function to get the configuration for the database and the tunnel,
+     * and then calls the `runWithTunnel` function to execute the query.
+     *
+     * @param psqlCmdArgs - Additional command-line arguments for psql (default: [])
+     * @returns Promise that resolves to the query result as a string
+     */
+    interactiveSession(psqlCmdArgs?: string[]): Promise<string>;
+    /**
+     * Runs the psql command with tunnel support.
+     *
+     * @param tunnelConfig - The tunnel configuration object
+     * @param options - The options for spawning the psql process
+     * @returns Promise that resolves to the query result as a string
+     */
+    runWithTunnel(tunnelConfig: TunnelConfig, options: Parameters<typeof this.spawnPsql>[0]): Promise<string>;
     /**
      * Consumes a stream and returns its content as a string.
      *
@@ -72,22 +105,32 @@ export default class PsqlService {
      */
     private kill;
     /**
-     * Creates the options for spawning the psql process.
+     * Creates the options for spawning the psql process for a SQL file execution.
      *
-     * @param query - The SQL query to execute
+     * @param file - The path to the SQL file to execute
      * @param dbEnv - The database environment variables
      * @param psqlCmdArgs - Additional command-line arguments for psql (default: [])
      * @returns Object containing child process options, database environment, and psql arguments
      */
-    private psqlQueryOptions;
+    private psqlFileOptions;
     /**
-     * Runs the psql command with tunnel support.
+     * Creates the options for spawning the psql process for an interactive psql session.
      *
-     * @param tunnelConfig - The tunnel configuration object
-     * @param options - The options for spawning the psql process
-     * @returns Promise that resolves to the query result as a string
+     * @param prompt - The prompt to use for the interactive psql session
+     * @param dbEnv - The database environment variables
+     * @param psqlCmdArgs - Additional command-line arguments for psql (default: [])
+     * @returns Object containing child process options, database environment, and psql arguments
      */
-    runWithTunnel(tunnelConfig: TunnelConfig, options: Parameters<typeof this.spawnPsql>[0]): Promise<string>;
+    private psqlInteractiveOptions;
+    /**
+     * Creates the options for spawning the psql process for a single query execution.
+     *
+     * @param query - The SQL query to execute
+     * @param dbEnv - The database environment variables
+     * @param psqlCmdArgs - Additional command-line arguments for psql (default: [])
+     * @returns Object containing child process options, database environment, and psql arguments
+     */
+    private psqlQueryOptions;
     /**
      * Spawns the psql process with the given options.
      *

package/dist/utils/pg/psql.js

@@ -1,6 +1,9 @@
+import { ux } from '@oclif/core';
 import debug from 'debug';
 import { spawn, } from 'node:child_process';
 import { EventEmitter, once } from 'node:events';
+import fs from 'node:fs';
+import path from 'node:path';
 import { Stream } from 'node:stream';
 import { finished } from 'node:stream/promises';
 import { getPsqlConfigs, sshTunnel } from './bastion.js';
@@ -83,6 +86,20 @@ export default class PsqlService {
         this.spawnFn = spawnFn;
         this.tunnelFn = tunnelFn;
     }
+    /**
+     * Executes a file containing SQL commands using the instance's database connection details.
+     * It uses the `getPsqlConfigs` function to get the configuration for the database and the tunnel,
+     * and then calls the `runWithTunnel` function to execute the file.
+     *
+     * @param file - The path to the SQL file to execute
+     * @param psqlCmdArgs - Additional command-line arguments for psql (default: [])
+     * @returns Promise that resolves to the query result as a string
+     */
+    async execFile(file, psqlCmdArgs = []) {
+        const configs = this.getPsqlConfigsFn(this.connectionDetails);
+        const options = this.psqlFileOptions(file, configs.dbEnv, psqlCmdArgs);
+        return this.runWithTunnel(configs.dbTunnelConfig, options);
+    }
     /**
      * Executes a PostgreSQL query using the instance's database connection details.
      * It uses the `getPsqlConfigs` function to get the configuration for the database and the tunnel,
@@ -97,6 +114,71 @@ export default class PsqlService {
         const options = this.psqlQueryOptions(query, configs.dbEnv, psqlCmdArgs);
         return this.runWithTunnel(configs.dbTunnelConfig, options);
     }
+    /**
+     * Fetches the PostgreSQL version from the database by executing the `SHOW server_version` query.
+     *
+     * @returns Promise that resolves to the PostgreSQL version as a string (or undefined).
+     */
+    async fetchVersion() {
+        const output = await this.execQuery('SHOW server_version', ['-X', '-q']);
+        return output.match(/\d+\.\d+/)?.[0];
+    }
+    /**
+     * Executes a PostgreSQL interactive session using the instance's database connection details.
+     * It uses the `getPsqlConfigs` function to get the configuration for the database and the tunnel,
+     * and then calls the `runWithTunnel` function to execute the query.
+     *
+     * @param psqlCmdArgs - Additional command-line arguments for psql (default: [])
+     * @returns Promise that resolves to the query result as a string
+     */
+    async interactiveSession(psqlCmdArgs = []) {
+        const attachmentName = this.connectionDetails.attachment.name;
+        const prompt = `${this.connectionDetails.attachment.app.name}::${attachmentName}%R%# `;
+        const configs = this.getPsqlConfigsFn(this.connectionDetails);
+        configs.dbEnv.PGAPPNAME = 'psql interactive'; // default was 'psql non-interactive`
+        const options = this.psqlInteractiveOptions(prompt, configs.dbEnv, psqlCmdArgs);
+        return this.runWithTunnel(configs.dbTunnelConfig, options);
+    }
+    /**
+     * Runs the psql command with tunnel support.
+     *
+     * @param tunnelConfig - The tunnel configuration object
+     * @param options - The options for spawning the psql process
+     * @returns Promise that resolves to the query result as a string
+     */
+    async runWithTunnel(tunnelConfig, options) {
+        const tunnel = await Tunnel.connect(this.connectionDetails, tunnelConfig, this.tunnelFn);
+        pgDebug('after create tunnel');
+        const psql = this.spawnPsql(options);
+        // Note: In non-interactive mode, psql.stdout is available for capturing output.
+        // In interactive mode, stdio: 'inherit' would make psql.stdout null.
+        // Return a string for consistency but ideally we should return the child process from this function
+        // and let the caller decide what to do with stdin/stdout/stderr
+        const stdoutPromise = psql.stdout ? this.consumeStream(psql.stdout) : Promise.resolve('');
+        const cleanupSignalTraps = this.trapAndForwardSignalsToChildProcess(psql);
+        try {
+            pgDebug('waiting for psql or tunnel to exit');
+            // wait for either psql or tunnel to exit;
+            // the important bit is that we ensure both processes are
+            // always cleaned up in the `finally` block below
+            await Promise.race([
+                this.waitForPSQLExit(psql),
+                tunnel.waitForClose(),
+            ]);
+        }
+        catch (error) {
+            pgDebug('wait for psql or tunnel error', error);
+            throw error;
+        }
+        finally {
+            pgDebug('begin tunnel cleanup');
+            cleanupSignalTraps();
+            tunnel.close();
+            this.kill(psql, 'SIGKILL');
+            pgDebug('end tunnel cleanup');
+        }
+        return stdoutPromise;
+    }
     /**
      * Consumes a stream and returns its content as a string.
      *
@@ -138,19 +220,19 @@ export default class PsqlService {
         }
     }
     /**
-     * Creates the options for spawning the psql process.
+     * Creates the options for spawning the psql process for a SQL file execution.
      *
-     * @param query - The SQL query to execute
+     * @param file - The path to the SQL file to execute
      * @param dbEnv - The database environment variables
      * @param psqlCmdArgs - Additional command-line arguments for psql (default: [])
      * @returns Object containing child process options, database environment, and psql arguments
      */
-    psqlQueryOptions(query, dbEnv, psqlCmdArgs = []) {
-        pgDebug('Running query: %s', query.trim());
-        const psqlArgs = ['-c', query, '--set', 'sslmode=require', ...psqlCmdArgs];
+    psqlFileOptions(file, dbEnv, psqlCmdArgs = []) {
+        pgDebug('Running SQL file: %s', file.trim());
         const childProcessOptions = {
             stdio: ['ignore', 'pipe', 'inherit'],
         };
+        const psqlArgs = ['-f', file, '--set', 'sslmode=require', ...psqlCmdArgs];
         return {
             childProcessOptions,
             dbEnv,
@@ -158,45 +240,59 @@ export default class PsqlService {
         };
     }
     /**
-     * Runs the psql command with tunnel support.
+     * Creates the options for spawning the psql process for an interactive psql session.
      *
-     * @param tunnelConfig - The tunnel configuration object
-     * @param options - The options for spawning the psql process
-     * @returns Promise that resolves to the query result as a string
+     * @param prompt - The prompt to use for the interactive psql session
+     * @param dbEnv - The database environment variables
+     * @param psqlCmdArgs - Additional command-line arguments for psql (default: [])
+     * @returns Object containing child process options, database environment, and psql arguments
      */
-    // eslint-disable-next-line perfectionist/sort-classes
-    async runWithTunnel(tunnelConfig, options) {
-        const tunnel = await Tunnel.connect(this.connectionDetails, tunnelConfig, this.tunnelFn);
-        pgDebug('after create tunnel');
-        const psql = this.spawnPsql(options);
-        // Note: In non-interactive mode, psql.stdout is available for capturing output.
-        // In interactive mode, stdio: 'inherit' would make psql.stdout null.
-        // Return a string for consistency but ideally we should return the child process from this function
-        // and let the caller decide what to do with stdin/stdout/stderr
-        const stdoutPromise = psql.stdout ? this.consumeStream(psql.stdout) : Promise.resolve('');
-        const cleanupSignalTraps = this.trapAndForwardSignalsToChildProcess(psql);
-        try {
-            pgDebug('waiting for psql or tunnel to exit');
-            // wait for either psql or tunnel to exit;
-            // the important bit is that we ensure both processes are
-            // always cleaned up in the `finally` block below
-            await Promise.race([
-                this.waitForPSQLExit(psql),
-                tunnel.waitForClose(),
-            ]);
-        }
-        catch (error) {
-            pgDebug('wait for psql or tunnel error', error);
-            throw error;
-        }
-        finally {
-            pgDebug('begin tunnel cleanup');
-            cleanupSignalTraps();
-            tunnel.close();
-            this.kill(psql, 'SIGKILL');
-            pgDebug('end tunnel cleanup');
+    psqlInteractiveOptions(prompt, dbEnv, psqlCmdArgs = []) {
+        let psqlArgs = ['--set', `PROMPT1=${prompt}`, '--set', `PROMPT2=${prompt}`];
+        const psqlHistoryPath = process.env.HEROKU_PSQL_HISTORY;
+        if (psqlHistoryPath) {
+            if (fs.existsSync(psqlHistoryPath) && fs.statSync(psqlHistoryPath).isDirectory()) {
+                const appLogFile = `${psqlHistoryPath}/${prompt.split(':')[0]}`;
+                pgDebug('Logging psql history to %s', appLogFile);
+                psqlArgs = [...psqlArgs, '--set', `HISTFILE=${appLogFile}`];
+            }
+            else if (fs.existsSync(path.dirname(psqlHistoryPath))) {
+                pgDebug('Logging psql history to %s', psqlHistoryPath);
+                psqlArgs = [...psqlArgs, '--set', `HISTFILE=${psqlHistoryPath}`];
+            }
+            else {
+                ux.warn(`HEROKU_PSQL_HISTORY is set but is not a valid path (${psqlHistoryPath})\n`);
+            }
         }
-        return stdoutPromise;
+        psqlArgs = [...psqlArgs, '--set', 'sslmode=require', ...psqlCmdArgs];
+        const childProcessOptions = {
+            stdio: ['inherit', 'inherit', 'inherit'],
+        };
+        return {
+            childProcessOptions,
+            dbEnv,
+            psqlArgs,
+        };
+    }
+    /**
+     * Creates the options for spawning the psql process for a single query execution.
+     *
+     * @param query - The SQL query to execute
+     * @param dbEnv - The database environment variables
+     * @param psqlCmdArgs - Additional command-line arguments for psql (default: [])
+     * @returns Object containing child process options, database environment, and psql arguments
+     */
+    psqlQueryOptions(query, dbEnv, psqlCmdArgs = []) {
+        pgDebug('Running query: %s', query.trim());
+        const psqlArgs = ['-c', query, '--set', 'sslmode=require', ...psqlCmdArgs];
+        const childProcessOptions = {
+            stdio: ['ignore', 'pipe', 'inherit'],
+        };
+        return {
+            childProcessOptions,
+            dbEnv,
+            psqlArgs,
+        };
     }
     /**
      * Spawns the psql process with the given options.

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@heroku/heroku-cli-util",
-  "version": "10.1.3-beta.0",
+  "version": "10.2.0",
   "description": "Set of helpful CLI utilities",
   "author": "Heroku",
   "license": "ISC",
@@ -21,6 +21,7 @@
     "@types/node": "^22.15.3",
     "@types/sinon": "^17.0.4",
     "@types/sinon-chai": "^4.0.0",
+    "@types/tmp": "^0.2.6",
     "@types/tunnel-ssh": "4.1.1",
     "c8": "^7.7.0",
     "chai": "^4.4.1",
@@ -36,6 +37,7 @@
     "sinon": "^18.0.1",
     "sinon-chai": "^3.7.0",
     "strip-ansi": "^6",
+    "tmp": "^0.2.5",
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",
     "tsheredoc": "^1.0.1",