refactor: dedupe listMetadata via Arr.dedupeAdjacentWith + Equivalence

Extract the fullName dedup into a named Effect Equivalence colocated
with FilePropertiesSchema, and use Arr.dedupeAdjacentWith instead of an
inline index filter. Decode now runs before sort/dedup so the
Equivalence operates on decoded values. Adds unit tests covering sort,
single-object coercion, dedup, and combined cases.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: mshanemc

packages/salesforcedx-vscode-services/src/core/metadataDescribeService.ts

@@ -6,6 +6,7 @@
  */
 
 import type { Connection } from '@salesforce/core';
+import * as Arr from 'effect/Array';
 import * as Cache from 'effect/Cache';
 import * as Chunk from 'effect/Chunk';
 import * as Duration from 'effect/Duration';
@@ -20,7 +21,7 @@ import { ExtensionContextService } from '../vscode/extensionContextService';
 import { SettingsService } from '../vscode/settingsService';
 import { ConnectionService } from './connectionService';
 import { getDefaultOrgRef } from './defaultOrgRef';
-import { FilePropertiesSchema } from './schemas/fileProperties';
+import { FilePropertiesByFullName, FilePropertiesSchema } from './schemas/fileProperties';
 import { unknownToErrorCause } from './shared';
 
 const NON_SUPPORTED_TYPES = new Set(['InstalledPackage', 'Profile', 'Scontrol']);
@@ -176,9 +177,9 @@ export class MetadataDescribeService extends Effect.Service<MetadataDescribeServ
         Effect.tap(result => Effect.annotateCurrentSpan({ result })),
         Effect.withSpan('listMetadata (API call)'),
         Effect.map(ensureArray),
-        Effect.map(arr => arr.toSorted((a, b) => a.fullName.localeCompare(b.fullName))),
-        Effect.map(arr => arr.filter((item, i, a) => i === 0 || item.fullName !== a[i - 1].fullName)),
         Effect.flatMap(arr => S.decodeUnknown(S.Array(FilePropertiesSchema))(arr)),
+        Effect.map(arr => arr.toSorted((a, b) => a.fullName.localeCompare(b.fullName))),
+        Effect.map(Arr.dedupeAdjacentWith(FilePropertiesByFullName)),
         Effect.mapError(e => {
           const { cause } = unknownToErrorCause(e);
           return new ListMetadataError({

packages/salesforcedx-vscode-services/src/core/schemas/fileProperties.ts

@@ -4,6 +4,7 @@
  * Licensed under the BSD 3-Clause license.
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
+import * as Equivalence from 'effect/Equivalence';
 import * as S from 'effect/Schema';
 
 /** Schema for FileProperties (metadata.list result) */
@@ -21,3 +22,9 @@ export const FilePropertiesSchema = S.Struct({
   manageableState: S.optional(S.String),
   namespacePrefix: S.optional(S.String)
 });
+
+/** Equivalence for FileProperties keyed on fullName — for deduping listMetadata results. */
+export const FilePropertiesByFullName = Equivalence.mapInput(
+  Equivalence.string,
+  (fp: S.Schema.Type<typeof FilePropertiesSchema>) => fp.fullName
+);

packages/salesforcedx-vscode-services/test/jest/core/metadataDescribeService.test.ts

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2026, salesforce.com, inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ */
+
+import type { Connection } from '@salesforce/core';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as SubscriptionRef from 'effect/SubscriptionRef';
+import { ChannelService } from '../../../src/vscode/channelService';
+import { ConnectionService } from '../../../src/core/connectionService';
+import { getDefaultOrgRef } from '../../../src/core/defaultOrgRef';
+import { MetadataDescribeService } from '../../../src/core/metadataDescribeService';
+
+type ListItem = {
+  fullName: string;
+  type: string;
+  id?: string;
+  lastModifiedDate?: string;
+};
+
+const createMockConnectionService = (listResult: ListItem | ListItem[]): Layer.Layer<ConnectionService> =>
+  Layer.succeed(
+    ConnectionService,
+    ConnectionService.make({
+      getConnection: () =>
+        Effect.succeed({
+          version: '60.0',
+          metadata: {
+            list: jest.fn().mockResolvedValue(listResult)
+          }
+        } as unknown as Connection),
+      invalidateCachedConnections: () => Effect.void
+    })
+  );
+
+const seedDefaultOrg = Effect.gen(function* () {
+  const ref = yield* getDefaultOrgRef();
+  yield* SubscriptionRef.update(ref, () => ({ orgId: 'test-org' }));
+});
+
+const runListMetadata = (listResult: ListItem | ListItem[], type = 'ApexClass') =>
+  Effect.runPromise(
+    Effect.gen(function* () {
+      yield* seedDefaultOrg;
+      const service = yield* MetadataDescribeService;
+      return yield* service.listMetadata(type);
+    }).pipe(
+      Effect.provide(
+        Layer.provide(
+          MetadataDescribeService.DefaultWithoutDependencies,
+          Layer.mergeAll(createMockConnectionService(listResult), ChannelService.Default)
+        )
+      )
+    )
+  );
+
+describe('MetadataDescribeService.listMetadata', () => {
+  it('sorts an out-of-order array by fullName', async () => {
+    const result = await runListMetadata([
+      { fullName: 'Charlie', type: 'ApexClass' },
+      { fullName: 'Alpha', type: 'ApexClass' },
+      { fullName: 'Bravo', type: 'ApexClass' }
+    ]);
+
+    expect(result.map(r => r.fullName)).toEqual(['Alpha', 'Bravo', 'Charlie']);
+  });
+
+  it('wraps a non-array (single object) response into an array of one', async () => {
+    const result = await runListMetadata({ fullName: 'Solo', type: 'ApexClass' });
+
+    expect(result).toHaveLength(1);
+    expect(result[0].fullName).toBe('Solo');
+  });
+
+  it('deduplicates entries with the same fullName', async () => {
+    const result = await runListMetadata([
+      { fullName: 'Dup', type: 'ApexClass', id: '1' },
+      { fullName: 'Dup', type: 'ApexClass', id: '2' },
+      { fullName: 'Unique', type: 'ApexClass' }
+    ]);
+
+    expect(result.map(r => r.fullName)).toEqual(['Dup', 'Unique']);
+  });
+
+  it('handles out-of-order, duplicate, and single-fullName entries together', async () => {
+    const result = await runListMetadata([
+      { fullName: 'Charlie', type: 'ApexClass', id: 'c1' },
+      { fullName: 'Alpha', type: 'ApexClass', id: 'a1' },
+      { fullName: 'Charlie', type: 'ApexClass', id: 'c2' },
+      { fullName: 'Bravo', type: 'ApexClass' },
+      { fullName: 'Alpha', type: 'ApexClass', id: 'a2' }
+    ]);
+
+    expect(result.map(r => r.fullName)).toEqual(['Alpha', 'Bravo', 'Charlie']);
+  });
+});