[$250] Number commercial card feed default names on NewDot

[robertjchen]

Problem

Expensify Classic pulls bank names/aliases from an authoritative bankList that has default names for various banks. This is displayed as the default name for feeds in Domain Control Company Cards when no custom name is set.

However, NewDot has it hardcoded. This is a problem when we have multiple feeds of vcf1, vcf2, etc. or cdf1, cdf2, they are not using the numbered names from the banklist, making it hard to disambiguate since all those feeds show up with a generic name.

Why is this important?

It's confusing for users, as multiple feeds of the same bank are indistinguishable in the feed list.

Platform: All (NewDot client-side rendering in CardUtils.ts)
Reproducible in staging?: Yes
Reproducible in production?: Yes

Action Performed

1. On a domain/workspace with multiple commercial feeds of the same bank (e.g. vcf, vcf2).
2. Open Workspace → Company cards → feed selector (or the search card-feed filter).

Expected Result

Each feed shows a disambiguated name matching Classic's banklist numbering, e.g. "Visa cards" and "Visa 2 cards".

Actual Result

Every feed of the same bank renders the identical generic label ("Visa cards"), because NewDot hardcodes feed-type → bank name and discards the key suffix.

Root Cause

getBankName() (src/libs/CardUtils.ts:713) prefix-matches the feed key against a static feedNamesMapping, so vcf/vcf2 both collapse to "Visa"; the suffix that Classic reads from the authoritative bankList is thrown away.

Solution (Scope)

Regenerate the number from the feed name itself (by taking off the suffix number). Note that not all suffixes are numbers, as there are entries like cdfbmo or vcfcitibank2. Scope this to only the numeric base families for now:

• vcf{N}, cdf{N}, gl1025{N}

Leave all other feed keys unchanged.

Acceptance criteria (feed key → display name)

Feed key	Display name	Note
vcf	Visa cards	no suffix → no number
vcf1	Visa cards	no suffix → no number
vcf2	Visa 2 cards	numeric suffix appended
vcfanzfav1	ANZ NZ 1 Cards	numeric suffix appended
cdf	Mastercard cards
cdf2	Mastercard 2 cards
gl1025	Amex cards	base key ends in digits, so NOT a suffix
gl10252	Amex 2 cards	suffix is what follows gl1025
cdfbmo	Mastercard cards	non-numeric suffix → leave alone
vcfcitibank2	(unchanged)	out of scope for now
custom nickname	(nickname wins)	unchanged behavior

Out of Scope

• Reading the actual banklist strings from the backend (would need a new API payload field; deferred).
• Other non-numeric feed families (cdfbmo, vcfcitibank*, etc.).

Manual Test Steps

1. Create two Visa VCF feeds; verify "Visa cards" / "Visa 2 cards".
2. Verify gl1025 (single Amex) still shows "Amex cards" (not "Amex 1025 cards").
3. Verify cdfbmo is untouched.
4. Verify a set custom nickname still overrides the generated name.

Automated Tests

Unit tests on the new suffix helper + getCustomOrFormattedFeedName covering the table above.

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022072692048823453147
• Upwork Job ID: 2072692048823453147
• Last Price Increase: 2026-07-16

[MelvinBot]

Proposal

What is the root cause of that problem?

getBankName() resolves a feed key to a bank name by prefix-matching it against the static feedNamesMapping:

CardUtils.ts:724

const feedKey = feedNamesMappingKeysByLength.find((feed) => feedType?.startsWith(feed));
result = feedKey ? feedNamesMapping[feedKey] : '';

vcf and vcf2 both start with vcf, so both collapse to Visa and the suffix that Classic reads from the authoritative bankList is discarded. The confirmed constants (VISA: 'vcf', MASTER_CARD: 'cdf', AMEX: 'gl1025', CONST/index.ts:4340) confirm the reporter's diagnosis. The feedName label is built as `${feedName} cards`, which is why every same-bank feed renders the identical generic label.

What changes do you think we should make in order to solve the problem?

Add a small helper that derives the numeric suffix from the feed key, then insert it into the display name only for the numeric base families vcf, cdf, gl1025.

Key detail that drives the design: the suffix must be computed relative to the matched family prefix, not as "trailing digits" — because the Amex base key gl1025 itself ends in digits (gl1025 → no number, gl10252 → number 2). This is the same technique already used by getFeedType() at CardUtils.ts:1221 (parseInt(str.replace(feedKey, ''), 10)).

Helper logic (pseudo-code):

getFeedNumberSuffix(feedKey):
    for base in [vcf, cdf, gl1025]:              // numeric families only
        if feedKey startsWith base:
            suffix = feedKey.slice(base.length)  // strip the matched prefix
            if suffix is all digits and non-empty:
                return Number(suffix)            // vcf2 -> 2, gl10252 -> 2
            return undefined                     // cdfbmo / vcfcitibank2 -> no number
    return undefined                             // gl1025 base -> no number

Apply it in getCustomOrFormattedFeedName() (CardUtils.ts:752-773) — i.e. build the label from `${bankName} ${number}` before the feedName translation so it reads "Visa 2 cards". Do not change getBankName() itself: it feeds icon lookups (e.g. getBankCardDetailsImage keyed on the exact BankName) and is called from ~10 other sites where numbering is not wanted; appending a number there would break those lookups.

This reproduces the full acceptance table (vcf→"Visa cards", vcf2→"Visa 2 cards", cdf2→"Mastercard 2 cards", gl1025→"Amex cards", gl10252→"Amex 2 cards", cdfbmo/vcfcitibank2 untouched, custom nickname still wins because customFeedName short-circuits first).

Edge case to handle in the helper

getCustomOrFormattedFeedName accepts CardFeedWithDomainID too (e.g. vcf.12345). Strip the domain first with getCompanyCardFeed(feed) before extracting the suffix, otherwise a domain-ID feed would be misread. AMEX_1205: 'gl1205' is a separate Amex family and is correctly left untouched, since it is not in the scoped {vcf, cdf, gl1025} set and gl10252 does not start with gl1205.

Unit tests: cover the new suffix helper (the full table above, including gl1025 vs gl10252 and non-numeric suffixes) plus getCustomOrFormattedFeedName for the nickname-wins and shouldAddCardsSuffix=false paths.

What alternative solutions did you explore? (Optional)

Reading the real strings from Classic's bankList — rejected/deferred by the issue as it needs a new API payload field. Regex trailing-digit extraction — rejected because it mis-parses the gl1025 Amex base key.

This is entirely App-side (src/libs/CardUtils.ts), so no backend change is needed.

---

Next Steps for Contributor+ team:
To accept: @MelvinBot implement [this](https://github.com/Expensify/App/issues/95206) to create a draft PR.
To refine: @MelvinBot <your feedback>
To reject: Explain why you are rejecting Melvin's proposal.

[kitvasyl]

Proposal

Please re-state the problem that we are trying to solve in this issue.

Numbered commercial card feeds such as vcf2, cdf2, and gl10252 display the same default name as their base feed, so users cannot distinguish multiple feeds unless they set custom nicknames.

What is the root cause of that problem?

WorkspaceCompanyCardFeedSelectorPage and CardFeedUtils.getCardFeedsForDisplay() both obtain labels through getCustomOrFormattedFeedName() in src/libs/CardUtils.ts.

That formatter calls getBankName(), whose feedNamesMappingKeysByLength.find((feed) => feedType.startsWith(feed)) branch resolves both vcf and vcf2 to Visa, both cdf and cdf2 to Mastercard, and both gl1025 and gl10252 to the existing Amex label. getCustomOrFormattedFeedName() then formats only that resolved bank name, so the numeric suffix has already been discarded. Search is affected too because getCardFeedsForDisplay() calls the formatter with shouldAddCardsSuffix=false.

What changes do you think we should make in order to solve the problem?

Add a local helper in src/libs/CardUtils.ts that first removes any domain-ID portion with getCompanyCardFeed(), selects only the explicit base families vcf, cdf, and gl1025, and examines the remaining substring. Return it only when the entire remainder matches ^\d+$; otherwise return no number. Selecting the base before slicing is important so gl1025 has no suffix while gl10252 yields 2, and non-numeric variants such as cdfbmo and vcfcitibank2 remain unchanged.

In getCustomOrFormattedFeedName(), append that number to the bank name before the existing shouldAddCardsSuffix branch. This gives both Visa 2 cards in selectors and Visa 2 in search data, while preserving the existing translation, unknown-feed fallback, and custom-nickname precedence. Keep getBankName() unchanged because its other callers expect a canonical bank name rather than a decorated feed label.

Add table-driven coverage in tests/unit/CardUtilsTest.ts for the base, numbered, non-numeric, gl1025/gl10252, domain-ID, custom-name, and shouldAddCardsSuffix=false cases. Add an integration assertion for a numbered feed in tests/unit/CardFeedUtilsTest.ts, then manually verify both the workspace feed selector and search card-feed filter.

What alternative solutions did you explore? (Optional)

Changing getBankName() directly would affect unrelated card descriptions and connection flows. Supplying Classic’s authoritative bank-list names from the backend would be more comprehensive, but requires an API payload change and is unnecessary for the scoped numeric families.

[shivang-goliyan]

🚨 Edited by proposal-police: This proposal was edited at 2026-07-02 14:46:36 UTC.

Proposal

Please re-state the problem that we are trying to solve in this issue.

When a domain or workspace has several commercial card feeds from the same bank (for example vcf and vcf2, or cdf and cdf2), NewDot shows the exact same default name for all of them, like "Visa cards" for every Visa feed. There's no way to tell the feeds apart in the selector, settings, or search filter. Expensify Classic disambiguates these with numbers ("Visa cards", "Visa 2 cards") pulled from its banklist, and we want NewDot to match.

What is the root cause of that problem?

getBankName() in src/libs/CardUtils.ts:713 resolves a feed key to a bank name by prefix-matching it against feedNamesMapping (longest prefix first) and returning only the bank string. The numeric suffix is dropped, so vcf, vcf2, and vcf3 all resolve to the same "Visa". The display helper getCustomOrFormattedFeedName() at line 752 then wraps that through translate('workspace.companyCards.feedName', feedName), producing "Visa cards" for every same-bank feed. This isn't a regression, it's an original design choice. getBankName was written to collapse feed variations on purpose (an old comment even called out vcf2/vcf3 as variations it intentionally normalized away), and its output is consumed as a BankName by the icon maps getBankCardDetailsImage/getCardFeedIcon and about ten other bank-detail call sites. Adding a number inside getBankName would feed "Visa 2" into those maps and break icon lookups everywhere.

One thing worth flagging for review: the acceptance table lists gl1025 → "Amex cards", but feedNamesMapping maps the AMEX base to COMPANY_CARDS.BANKS.AMEX, which is the string American Express. So the real rendered output is "American Express cards" / "American Express 2 cards". The table's "Amex/Visa/Mastercard" are shorthand for the bank labels, not the literal strings, and the existing bank labels shouldn't change here.

What changes do you think we should make in order to solve the problem?

Fix this at the centralized display layer, getCustomOrFormattedFeedName(), which already receives the raw feed key and is the single function every feed-name UI goes through (the selector page, settings page, table header, useOtherFeedsForFeedSelector, and FixCompanyCardConnection). It does not feed the icon maps, so it's safe to add the number there.

Add a small helper that derives the suffix number from the feed key, scoped to the three numbered base families (FEED_BANK_NAME.VISA = vcf, MASTER_CARD = cdf, AMEX = gl1025):

function getFeedSuffixNumber(feed): string {
    const feedKey = splitCardFeedWithDomainID(feed)?.feedName ?? feed;
    const base = NUMBERED_FEED_BASES.find((b) => feedKey.startsWith(b));
    const suffix = base ? feedKey.slice(base.length) : '';
    return /^\d+$/.test(suffix) ? suffix : '';
}

The splitCardFeedWithDomainID call (line 916) strips a trailing #domainID first, so vcf2#123 correctly reduces to vcf2 before the regex runs. This is the same startsWith + slice + numeric-suffix pattern already used by collectUsedCSVFeedSlotNumbersFromCompanyCards (line 1177), and the three base families line up with the existing CUSTOM_FEEDS list (line 1175). Then in getCustomOrFormattedFeedName, insert the number before the "cards" suffix is applied:

const feedName = getBankName(feed);
const num = getFeedSuffixNumber(feed);
const named = feedName && num ? `${feedName} ${num}` : feedName;
const formattedFeedName = named && shouldAddCardsSuffix ? translate('workspace.companyCards.feedName', named) : named;

Keep the existing customFeedName || formattedFeedName || feed fallback (and its eslint-disable) so a set nickname still wins. Because the number is inserted into the name argument, it works in both EN ("Visa 2 cards") and ES ("Tarjetas Visa 2") with no translation change. This covers the whole table: vcf → no number, vcf2/cdf2/gl10252 → numbered, gl1025 → no number (the digits are part of the base), and cdfbmo/vcfcitibank2 → untouched because the suffix isn't purely digits.

For tests, tests/unit/CardUtilsTest.ts currently only covers custom-name / base Visa / undefined / unknown cases for getCustomOrFormattedFeedName (describe block at line 1427) and has nothing for numeric suffixes. I'd add cases for vcf2, cdf2, gl10252, gl1025 (asserts no number), cdfbmo (untouched), a custom nickname overriding vcf2, and shouldAddCardsSuffix=false, asserting the actual bank strings. I'd also add direct tests for getFeedSuffixNumber.

What alternative solutions did you explore? (Optional)

I looked at adding the number inside getBankName itself, but its return value is a BankName that keys the icon maps and roughly ten bank-detail callers, so "Visa 2" would break all of them. I also considered injecting the number in the feedName translation string, but the translation only receives the bank name, not the feed key, and callers passing shouldAddCardsSuffix=false skip translation entirely, so the number would be lost. Doing it in getCustomOrFormattedFeedName is the one layer that has the raw key and doesn't touch icons.

[ahmdshrif]

🚨 Edited by proposal-police: This proposal was edited at 2026-07-02 14:42:24 UTC.

Proposal

Please re-state the problem that we are trying to solve in this issue.

When a workspace/domain has more than one commercial feed of the same bank (e.g. vcf and vcf2, or cdf and cdf2), NewDot renders every one of them with the identical generic default name ("Visa cards"), so they can't be told apart. Classic disambiguates them with a number ("Visa cards" / "Visa 2 cards") from its authoritative bankList; NewDot should do the same for the numeric feed families.

What is the root cause of that problem?

A second feed of the same bank is stored under a key with a numeric suffix — the key type is `${CardFeed}${number}` (optionally followed by #<domainID>), e.g. vcf, vcf2:

App/src/types/onyx/CardFeeds.ts

Lines 23 to 28 in a56c3e3

	type CardFeedWithNumber = CardFeed | `${CardFeed}${number}`;
	/**
	* Card feed name with domain ID
	*/
	type CardFeedWithDomainID = `${CardFeedWithNumber}${typeof CONST.COMPANY_CARD.FEED_KEY_SEPARATOR}${string}`;

1. getBankName() resolves the bank with feedType.startsWith(feed) against feedNamesMapping, which matches only the base key and discards the trailing number, so vcf and vcf2 both return "Visa":
   

   App/src/libs/CardUtils.ts

   Lines 713 to 733 in a56c3e3

   	function getBankName(feedType: CardFeedWithNumber | CardFeedWithDomainID): string {
   	const cacheKey = feedType ?? '';
   	const cached = getBankNameCache.get(cacheKey);
   	if (cached !== undefined) {
   	return cached;
   	}
   	let result: string;
   	if (feedType?.includes(CONST.COMPANY_CARD.FEED_BANK_NAME.CSV)) {
   	result = CONST.COMPANY_CARDS.CARD_TYPE.CSV;
   	} else {
   	const feedKey = feedNamesMappingKeysByLength.find((feed) => feedType?.startsWith(feed));
   	result = feedKey ? feedNamesMapping[feedKey] : '';
   	}
   	if (getBankNameCache.size >= GET_BANK_NAME_CACHE_MAX_SIZE) {
   	getBankNameCache.clear();
   	}
   	getBankNameCache.set(cacheKey, result);
   	return result;
   	}

2. This same collapsed name then flows into both feed-name display paths, which is why the duplication shows up in more than one place:

• Feed selector / settings / table header, via getCustomOrFormattedFeedName():
  

  App/src/libs/CardUtils.ts

  Lines 752 to 773 in a56c3e3

  	function getCustomOrFormattedFeedName(
  	translate: LocalizedTranslate,
  	feed?: CardFeedWithNumber | CardFeedWithDomainID,
  	customFeedName?: string,
  	shouldAddCardsSuffix = true,
  	): string | undefined {
  	if (!feed) {
  	return;
  	}
  	if (customFeedName && typeof customFeedName !== 'string') {
  	return '';
  	}
  	const feedName = getBankName(feed);
  	const formattedFeedName = feedName && shouldAddCardsSuffix ? translate('workspace.companyCards.feedName', feedName) : feedName;
  	// Custom feed name can be empty. Fallback to default feed name
  	// Fallback to feed key name for unknown feeds
  	// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
  	return customFeedName || formattedFeedName || feed;
  	}

• The search card-feed filter (the second repro surface), via getCardFeedBankDisplayName(), called from getWorkspaceCardFeedData and getDomainCardFeedData:
  

  App/src/libs/CardFeedUtils.ts

  Lines 465 to 473 in a56c3e3

  	function getCardFeedBankDisplayName(bank: string, feedCountry: string | undefined, companyCardBankName: string, translate: LocaleContextProps['translate']): string {
  	if (bank !== CONST.EXPENSIFY_CARD.BANK) {
  	return companyCardBankName;
  	}
  	if (feedCountry === CONST.TRAVEL.PROGRAM_TRAVEL_US) {
  	return translate('search.filters.card.travelInvoicing');
  	}
  	return translate('search.filters.card.expensify');
  	}

  
  

  App/src/libs/CardFeedUtils.ts

  Lines 229 to 250 in a56c3e3

  	const companyCardBank = isPlaid && cardName ? cardName : getBankName(bank);
  	const feedCountry = getFeedCountryForDisplay(representativeCard);
  	const cardFeedBankName = getCardFeedBankDisplayName(bank, feedCountry, companyCardBank, translate);
  	const fullCardName =
  	cardFeedBankName === CONST.COMPANY_CARDS.CARD_TYPE.CSV
  	? translate('search.filters.card.cardFeedNameCSV', {cardFeedLabel})
  	: translate('search.filters.card.cardFeedName', {cardFeedBankName, cardFeedLabel});
  	return {
  	cardName: fullCardName,
  	bank,
  	label: cardFeedLabel,
  	type: 'workspace',
  	...(feedCountry ? {feedCountry} : {}),
  	};
  	}
  	function getDomainCardFeedData(domainFeed: DomainFeedData, policies: OnyxCollection<Policy>, repeatingBanks: string[], translate: LocaleContextProps['translate']): CardFeedData {
  	const {domainName, bank, feedCountry} = domainFeed;
  	const isBankRepeating = repeatingBanks.includes(bank);
  	const cardFeedBankName = getCardFeedBankDisplayName(bank, feedCountry, getBankName(bank), translate);

Structural cause: getBankName() is (correctly) a bank-identity function — its BankName return is consumed by the icon map and per-card labels (see next section) — but no layer re-derives the per-feed number that Classic reads from bankList. The number is simply dropped at both display points. This explains every symptom: both the feed selector and the search filter list show the generic name for vcf/vcf2/cdf/cdf2.

What changes do you think we should make in order to solve the problem?

Add one small helper in CardUtils.ts that re-derives the number from the feed key, scoped to the three numeric base families, and append it at the two display points only.

const NUMBERED_FEED_BASES = [
    CONST.COMPANY_CARD.FEED_BANK_NAME.VISA,        // vcf
    CONST.COMPANY_CARD.FEED_BANK_NAME.MASTER_CARD, // cdf
    CONST.COMPANY_CARD.FEED_BANK_NAME.AMEX,        // gl1025
];
function getFeedNumberSuffix(feed: string): string {
    const key = feed.split(CONST.COMPANY_CARD.FEED_KEY_SEPARATOR).at(0) ?? ''; // drop #domainID
    const base = NUMBERED_FEED_BASES.find((p) => key.startsWith(p));
    const suffix = base ? key.slice(base.length) : '';
    return /^\d+$/.test(suffix) ? suffix : ''; // only a purely-numeric suffix counts
}

Then in getCustomOrFormattedFeedName() (L766) build the name from getBankName(feed) + the suffix, and in getCardFeedBankDisplayName() (non-Expensify branch, L466-467) return suffix ? `${companyCardBankName} ${suffix}` : companyCardBankName — one edit there covers both search-filter callers.

Regression safety: getBankName() is untouched, so the icon map and per-card labels are unaffected; the number is added only for vcf/cdf/gl1025 keys with a purely-numeric suffix, and the custom-nickname branch (customFeedName || …) still wins. This matches the acceptance table exactly: gl1025 → remainder '' → "Amex cards"; gl10252 → "Amex 2 cards"; cdfbmo → suffix bmo non-numeric → untouched; vcfcitibank2 → suffix citibank2 non-numeric → untouched.

Why the obvious one-liner fails: appending the number inside getBankName() (or a bare feed.match(/\d+$/)) looks simpler but is wrong on two counts. (1) getBankName()'s BankName return keys the icon map in getBankCardDetailsImage and the per-card row label in getCardDescription (L217 → "Visa • 1234"), plus DetailsStep/BankConnection/CardInstructionsStep — numbering it makes iconMap["Visa 2"] undefined and mislabels individual cards. (2) a trailing-\d+ regex extracts 1025 from gl1025, wrongly numbers vcfcitibank2, and grabs the domain-ID from vcf2#123; anchoring to the mapped base key + purely-numeric test is what makes the scope table hold.

What alternative solutions did you explore? (Optional)

• Number inside getBankName() — rejected: breaks the icon lookup and per-card labels described above; that function must stay a pure bank-identity resolver.
• Patch only getCustomOrFormattedFeedName() (the feed-selector path) — incomplete: the search card-feed filter renders through getCardFeedBankDisplayName() and would still show duplicate names.
• Read the numbered strings from the backend bankList — out of scope per the issue (needs a new API field); the in-repo suffix derivation is the mergeable fix now.

Unit tests: extend tests/unit/CardUtilsTest.ts to cover the acceptance table (vcf/vcf2/cdf2/gl1025/gl10252/cdfbmo/vcfcitibank2 + custom nickname).

[lorretheboy]

Proposal

What is the root cause of that problem?

getBankName() resolves a feed's display name by prefix-matching the feed key against the static feedNamesMapping and returning only the mapped bank name — everything after the matched base key is discarded:

App/src/libs/CardUtils.ts

Lines 713 to 733 in a56c3e3

	function getBankName(feedType: CardFeedWithNumber | CardFeedWithDomainID): string {
	const cacheKey = feedType ?? '';
	const cached = getBankNameCache.get(cacheKey);
	if (cached !== undefined) {
	return cached;
	}
	let result: string;
	if (feedType?.includes(CONST.COMPANY_CARD.FEED_BANK_NAME.CSV)) {
	result = CONST.COMPANY_CARDS.CARD_TYPE.CSV;
	} else {
	const feedKey = feedNamesMappingKeysByLength.find((feed) => feedType?.startsWith(feed));
	result = feedKey ? feedNamesMapping[feedKey] : '';
	}
	if (getBankNameCache.size >= GET_BANK_NAME_CACHE_MAX_SIZE) {
	getBankNameCache.clear();
	}
	getBankNameCache.set(cacheKey, result);
	return result;
	}

So vcf and vcf2 both match the vcf entry and collapse to "Visa". getCustomOrFormattedFeedName() then just appends the "cards" suffix to that name, so every feed of the same bank renders the identical label:

App/src/libs/CardUtils.ts

Lines 766 to 772 in a56c3e3

	const feedName = getBankName(feed);
	const formattedFeedName = feedName && shouldAddCardsSuffix ? translate('workspace.companyCards.feedName', feedName) : feedName;
	// Custom feed name can be empty. Fallback to default feed name
	// Fallback to feed key name for unknown feeds
	// eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
	return customFeedName || formattedFeedName || feed;

Classic doesn't have this problem because it reads numbered names ("Visa 2") from the backend bankList; NewDot never receives that data, and the client-side fallback throws the numeric suffix away.

What changes do you think we should make in order to solve the problem?

Fix it inside getBankName() — it's the single convergence point, so the feed selector, Search card-feed filter (via getCardFeedName), and every other caller get the numbered name for free, and custom nicknames still win because getCustomOrFormattedFeedName returns customFeedName before the generated name.

After the prefix match in the feedNamesMappingKeysByLength.find branch:

1. Strip any #domainID part first using the existing splitCardFeedWithDomainID() (feed keys can look like vcf2#12345):

App/src/libs/CardUtils.ts

Lines 916 to 921 in a56c3e3

	function splitCardFeedWithDomainID(feedName: CardFeedWithNumber | CardFeedWithDomainID | undefined): {feedName: CardFeedWithNumber; domainID: number | undefined} | undefined {
	if (!feedName) {
	return;
	}
	const feedNameParts = feedName.split(CONST.COMPANY_CARD.FEED_KEY_SEPARATOR);

2. Take the remainder of the feed key after the matched base key. If the base key is one of the numeric families (vcf, cdf, gl1025) and the remainder is a non-empty all-digit string, append it: result = ${feedNamesMapping[feedKey]} ${suffix}``. Otherwise keep the current behavior.

Pseudo-code:

const feedKey = feedNamesMappingKeysByLength.find((feed) => baseFeedName?.startsWith(feed));
let result = feedKey ? feedNamesMapping[feedKey] : '';
const NUMBERED_FEED_BASES = [FEED_BANK_NAME.VISA, FEED_BANK_NAME.MASTER_CARD, FEED_BANK_NAME.AMEX];
const suffix = feedKey ? baseFeedName.slice(feedKey.length) : '';
if (result && NUMBERED_FEED_BASES.includes(feedKey) && /^\d+$/.test(suffix)) {
    result = `${result} ${suffix}`;
}

This satisfies the whole acceptance table: vcf2 → "Visa 2 cards", gl1025 → "Amex cards" (empty remainder → no number), gl10252 → "Amex 2 cards", cdfbmo/vcfcitibank2 → non-digit remainder → unchanged. The existing getBankNameCache already keys on the full feed key, so different suffixes cache separately. Add unit tests covering the table for getBankName and getCustomOrFormattedFeedName.

What alternative solutions did you explore? (Optional)

Appending the number in getCustomOrFormattedFeedName() instead — rejected because other surfaces call getBankName() directly and would keep showing ambiguous names; fixing the shared helper covers them all.

[yusufdeveloper2903]

Proposal

What is the root cause of that problem?

Every feed default name is built in getCustomOrFormattedFeedName, which asks getBankName for the bank label and then wraps it with the " cards" suffix:

App/src/libs/CardUtils.ts

Lines 766 to 767 in a9e6aed

	const feedName = getBankName(feed);
	const formattedFeedName = feedName && shouldAddCardsSuffix ? translate('workspace.companyCards.feedName', feedName) : feedName;

getBankName resolves a feed key to a bank label by prefix-matching it against the static feedNamesMapping:

App/src/libs/CardUtils.ts

Lines 724 to 725 in a9e6aed

	const feedKey = feedNamesMappingKeysByLength.find((feed) => feedType?.startsWith(feed));
	result = feedKey ? feedNamesMapping[feedKey] : '';

The mapping keys are the bare base families vcf/cdf/gl1025:

App/src/libs/CardUtils.ts

Lines 117 to 134 in a9e6aed

	const feedNamesMapping = {
	[CONST.COMPANY_CARD.FEED_BANK_NAME.CSV]: CONST.COMPANY_CARDS.CARD_TYPE_NAMES.CSV,
	[CONST.COMPANY_CARD.FEED_BANK_NAME.VISA]: CONST.COMPANY_CARDS.CARD_TYPE_NAMES.VISA,
	[CONST.COMPANY_CARD.FEED_BANK_NAME.MASTER_CARD]: CONST.COMPANY_CARDS.CARD_TYPE_NAMES.MASTERCARD,
	[CONST.COMPANY_CARD.FEED_BANK_NAME.AMEX]: CONST.COMPANY_CARDS.BANKS.AMEX,
	[CONST.COMPANY_CARD.FEED_BANK_NAME.STRIPE]: CONST.COMPANY_CARDS.BANKS.STRIPE,
	[CONST.COMPANY_CARD.FEED_BANK_NAME.AMEX_DIRECT]: CONST.COMPANY_CARDS.BANKS.AMEX,
	[CONST.COMPANY_CARD.FEED_BANK_NAME.BANK_OF_AMERICA]: CONST.COMPANY_CARDS.BANKS.BANK_OF_AMERICA,
	[CONST.COMPANY_CARD.FEED_BANK_NAME.CAPITAL_ONE]: CONST.COMPANY_CARDS.BANKS.CAPITAL_ONE,
	[CONST.COMPANY_CARD.FEED_BANK_NAME.CHASE]: CONST.COMPANY_CARDS.BANKS.CHASE,
	[CONST.COMPANY_CARD.FEED_BANK_NAME.CITIBANK]: CONST.COMPANY_CARDS.BANKS.CITI_BANK,
	[CONST.COMPANY_CARD.FEED_BANK_NAME.WELLS_FARGO]: CONST.COMPANY_CARDS.BANKS.WELLS_FARGO,
	[CONST.COMPANY_CARD.FEED_BANK_NAME.BREX]: CONST.COMPANY_CARDS.BANKS.BREX,
	[CONST.COMPANY_CARD.FEED_BANK_NAME.AMEX_1205]: CONST.COMPANY_CARDS.BANKS.AMEX,
	[CONST.COMPANY_CARD.FEED_BANK_NAME.AMEX_FILE_DOWNLOAD]: CONST.COMPANY_CARDS.BANKS.AMEX,
	[CONST.COMPANY_CARD.FEED_BANK_NAME.MOCK_BANK]: CONST.COMPANY_CARDS.BANKS.MOCK_BANK,
	[CONST.COMPANY_CARD.FEED_BANK_NAME.PEX]: CONST.COMPANY_CARDS.NON_CONNECTABLE_BANKS.PEX,
	} satisfies Partial<Record<CardFeed, BankName | NonConnectableBankName | CardTypeName>>;

App/src/CONST/index.ts

Lines 4340 to 4342 in a9e6aed

	MASTER_CARD: 'cdf',
	VISA: 'vcf',
	AMEX: 'gl1025',

Because the match is feedType.startsWith(feed), a numbered second feed such as vcf2 still matches the vcf key and returns "Visa" — the part of the key after the base family (the 2) is dropped before the name is ever formatted. The feedName translation then just appends " cards":

App/src/languages/en.ts

Line 5689 in a9e6aed

feedName: (feedName: string) => `${feedName} cards`,

So: when a bank has more than one feed (vcf, vcf2, …), the numeric suffix that Classic reads from its authoritative bankList is discarded at the prefix match, so every feed of that bank formats to the identical label ("Visa cards") and users can't tell them apart.

Both live surfaces named in the report converge on this one formatter, which is why the fix is single-point:

• Feed selector / settings / table header → getCustomOrFormattedFeedName directly (WorkspaceCompanyCardFeedSelectorPage.tsx#L91).
• Search card-feed filter → getCardFeedsForDisplay (CardFeedUtils.ts#L539), which passes the raw feed key (suffix intact) into getCustomOrFormattedFeedName; this is what SearchUIUtils/autocomplete render (SearchUIUtils.ts#L4885).

Note on the other getBankName(card.bank) path — getWorkspaceCardFeedData/getDomainCardFeedData also derive a feed name from card.bank (which is itself CardFeedWithNumber, Card.ts#L56) via getCardFeedBankDisplayName (CardFeedUtils.ts#L250) and drop the number the same way — but that output is consumed only by getCardFeedNamesWithType and buildCardFeedsData, neither of which has a non-test caller in the codebase. So it is not a live surface today and does not need a second edit for this bug (see Alternatives).

What changes do you think we should make in order to solve the problem?

Reuse-first, single point. The codebase already has the exact scoped set as a constant — CUSTOM_FEED_PREFIXES is [cdf, vcf, gl1025], already in scope in this file and already used by isCustomFeed:

App/src/libs/CardUtils.ts

Line 115 in a9e6aed

const CUSTOM_FEED_PREFIXES = [CONST.COMPANY_CARD.FEED_BANK_NAME.MASTER_CARD, CONST.COMPANY_CARD.FEED_BANK_NAME.VISA, CONST.COMPANY_CARD.FEED_BANK_NAME.AMEX];

App/src/libs/CardUtils.ts

Lines 600 to 606 in a9e6aed

	function isCustomFeed(feed: string | undefined): boolean {
	if (!feed) {
	return false;
	}
	return CUSTOM_FEED_PREFIXES.some((value) => feed.startsWith(value));
	}

Add a tiny helper that mirrors the existing "slice the matched base prefix, parse the remainder" pattern already used by collectUsedCSVFeedSlotNumbersFromCompanyCards (CardUtils.ts#L1178-L1194) and getFeedType (CardUtils.ts#L1221), and stripping any #domainID first with the existing getCompanyCardFeed (CardUtils.ts#L1532):

+ function getFeedNumberSuffix(feed: CardFeedWithNumber | CardFeedWithDomainID): string {
+     const feedKey = getCompanyCardFeed(feed); // drop #domainID
+     const base = CUSTOM_FEED_PREFIXES.find((prefix) => feedKey.startsWith(prefix));
+     const suffix = base ? feedKey.slice(base.length) : '';
+     // only a purely-numeric remainder counts: vcf2 -> '2', gl10252 -> '2', gl1025/cdfbmo/vcfcitibank2 -> ''
+     return /^\d+$/.test(suffix) ? suffix : '';
+ }

Slicing the matched base prefix (not "trailing digits") is what makes the Amex base key gl1025 — which itself ends in digits — resolve to no number, while gl10252 yields 2.

Then splice the number in before the existing shouldAddCardsSuffix wrapping in getCustomOrFormattedFeedName, leaving getBankName untouched:

- const feedName = getBankName(feed);
+ const numberSuffix = getFeedNumberSuffix(feed);
+ const feedName = numberSuffix ? `${getBankName(feed)} ${numberSuffix}` : getBankName(feed);
  const formattedFeedName = feedName && shouldAddCardsSuffix ? translate('workspace.companyCards.feedName', feedName) : feedName;

This reproduces the whole acceptance table for both live surfaces: selector reads Visa 2 cards, search (shouldAddCardsSuffix=false) reads Visa 2; vcf→Visa cards, cdf2→Mastercard 2 cards, gl1025→Amex cards, gl10252→Amex 2 cards; cdfbmo/vcfcitibank2 fail the ^\d+$ test and are left unchanged; and the custom-nickname branch (customFeedName || …) still short-circuits first so a set nickname wins. getBankName stays a pure bank-identity resolver, so the icon map (getBankCardDetailsImage) and the ~10 per-card callers (CardUtils.ts#L217) are unaffected. Unit tests on getFeedNumberSuffix + getCustomOrFormattedFeedName covering the table (including the gl1025-vs-gl10252 and domain-ID cases) round it out; minor changes can be discussed in the PR phase.

What alternative solutions did you explore? (Optional)

• Fix inside getBankName() (some might argue it's the single convergence point) — rejected: its BankName return keys the icon map and labels individual cards (getCardDescription at L217, DetailsStep/BankConnection), so decorating it with a number makes iconMap["Visa 2"] undefined and mislabels single cards. The formatter layer is the correct place.
• Also patch getCardFeedBankDisplayName / the getBankName(card.bank) path — not needed for this bug: its only consumers, getCardFeedNamesWithType and buildCardFeedsData, have no non-test callers, so it renders nowhere today. If we want to future-proof it, the same getFeedNumberSuffix helper can be applied there in one line, but that's outside the scope of the live regression and would only add surface area now.
• Read Classic's authoritative bankList strings from the backend — deferred by the issue (needs a new API payload field).

[KJ21-ENG]

🚨 Edited by proposal-police: This proposal was edited at 2026-07-02 15:55:08 UTC.

Proposal

What is the root cause of that problem?

NewDot derives company card feed display names from a static App-side feed prefix map. feedNamesMapping maps known feed prefixes to a canonical bank/card name, and feedNamesMappingKeysByLength keeps the prefix matching longest-first for existing feed variations.

https://github.com/Expensify/App/blob/main/src/libs/CardUtils.ts#L117-L137

getBankName() then returns only that mapped base name:

https://github.com/Expensify/App/blob/main/src/libs/CardUtils.ts#L713-L733

So feeds like vcf1, vcf2, cdf2, and gl10252 all collapse to Visa, Mastercard, or American Express before the UI label is built. getCustomOrFormattedFeedName() formats only that collapsed name with the existing cards suffix, so the numeric/alias suffix from the feed key is lost in the default display path.

https://github.com/Expensify/App/blob/main/src/libs/CardUtils.ts#L752-L773

This affects both places called out in the issue:

• Workspace > Company cards feed selector calls getCustomOrFormattedFeedName() for each row.
  https://github.com/Expensify/App/blob/main/src/pages/workspace/companyCards/WorkspaceCompanyCardFeedSelectorPage.tsx#L78-L92
• The search card-feed filter uses getCardFeedsForDisplay(), which also calls getCustomOrFormattedFeedName(..., false) for the filter option/chip label.
  https://github.com/Expensify/App/blob/main/src/libs/CardFeedUtils.ts#L512-L547

getBankName() itself should stay a canonical bank-name resolver. It is also used by card descriptions, connection/setup flows, card-feed icons, and bank-detail image lookup paths where values like Visa 2 or ANZ NZ 1 would not be valid bank identity keys.

One new requirement in the updated issue body is important: vcf1 should still display as Visa cards, while vcf2 should display as Visa 2 cards. So we cannot simply append every numeric suffix.

Another updated requirement is vcfanzfav1 -> ANZ NZ 1 Cards. Current NewDot does not have a vcfanzfav / ANZ NZ entry in feedNamesMapping or CONST.COMPANY_CARD.FEED_BANK_NAME; without backend bankList data, App cannot derive ANZ NZ generically from vcfanzfav1. To satisfy the current issue scope client-side, we need to add this as a scoped display-only alias instead of changing all non-numeric feed families.

What changes do you think we should make in order to solve the problem?

Keep getBankName() unchanged, and add a display-only helper used by getCustomOrFormattedFeedName().

The helper should:

1. Normalize the feed first with getCompanyCardFeed() so keys with a domain suffix are evaluated as the actual feed key.
   https://github.com/Expensify/App/blob/main/src/libs/CardUtils.ts#L1532-L1539

2. Match only the scoped display families:

   • vcf -> base label from the current Visa mapping
   • cdf -> base label from the current Mastercard mapping
   • gl1025 -> base label from the current American Express mapping
   • vcfanzfav -> scoped display alias ANZ NZ

3. Slice the suffix relative to the matched family prefix, not with a generic trailing-digit regex. This avoids misreading gl1025 as suffix 1025 and keeps gl10252 as suffix 2.

4. Apply the display-number rule per family:

   • For vcf, cdf, and gl1025: no number for empty suffix or suffix 1; show numeric suffixes greater than 1.
   • For vcfanzfav: show the numeric suffix, including 1, because the updated acceptance table explicitly expects ANZ NZ 1 Cards.
   • For non-numeric remainders such as cdfbmo or vcfcitibank2: do not add a generated number; preserve the current unchanged fallback behavior.

Then in getCustomOrFormattedFeedName(), use that helper before the existing translation:

const displayFeedName = getDisplayFeedName(feed) || getBankName(feed);
const formattedFeedName = displayFeedName && shouldAddCardsSuffix ? translate('workspace.companyCards.feedName', displayFeedName) : displayFeedName;

The existing return behavior should stay the same, so custom nicknames still win:

return customFeedName || formattedFeedName || feed;

This keeps the change centralized. The workspace selector gets Visa 2 cards, and the search card-feed filter gets Visa 2 because it already calls the same formatter with shouldAddCardsSuffix=false.

Expected behavior from the updated issue body:

• vcf -> Visa cards
• vcf1 -> Visa cards
• vcf2 -> Visa 2 cards
• vcfanzfav1 -> ANZ NZ 1 cards via the scoped display alias
• cdf -> Mastercard cards
• cdf2 -> Mastercard 2 cards
• gl1025 -> American Express cards
• gl10252 -> American Express 2 cards
• cdfbmo -> current Mastercard fallback, without generated numbering
• vcfcitibank2 -> unchanged / out of scope, without generated numbering
• custom nickname -> unchanged, nickname wins

Test coverage:

• Add table-driven getCustomOrFormattedFeedName() tests in tests/unit/CardUtilsTest.ts for every acceptance row, including vcf1, vcf2, vcfanzfav1, gl1025, gl10252, cdfbmo, vcfcitibank2, custom nickname, and shouldAddCardsSuffix=false.
  https://github.com/Expensify/App/blob/main/tests/unit/CardUtilsTest.ts#L1427-L1455
• Keep/add getBankName() tests proving getBankName('vcf2') still returns the canonical Visa, not Visa 2, to protect icon/detail callers.
  https://github.com/Expensify/App/blob/main/tests/unit/CardUtilsTest.ts#L1650-L1692
• Add getCardFeedsForDisplay() coverage in tests/unit/CardFeedUtilsTest.ts so the search card-feed filter path also resolves numbered feed labels correctly.
  https://github.com/Expensify/App/blob/main/tests/unit/CardFeedUtilsTest.ts#L172-L190

What alternative solutions did you explore? (Optional)

Reading Classic's authoritative bankList strings from the backend would be the cleanest long-term source for aliases like ANZ NZ, but the issue explicitly scopes a backend/API payload change out.

Changing getBankName() directly is unsafe because it is a bank-identity helper used by non-display callers and icon/detail maps.

Using a generic trailing-number regex is also unsafe because it mis-parses feed bases that already contain digits, especially gl1025.

[melvin-bot]

Triggered auto assignment to Contributor-plus team member for initial proposal review - @gijoe0295 (External)

[melvin-bot]

Job added to Upwork: https://www.upwork.com/jobs/~022072692048823453147