fix: slas client list returns empty list when tenant doesn't exist (#138)

When listing SLAS clients for a tenant that doesn't exist yet, the API
returns a 401 ClientTenantException. Instead of surfacing this confusing
error, check if the tenant exists and return an empty list if not.

Closes #126

Author: clavery

.changeset/slas-list-empty-on-no-tenant.md

@@ -0,0 +1,5 @@
+---
+'@salesforce/b2c-cli': patch
+---
+
+`slas client list` now returns an empty list instead of erroring when the SLAS tenant doesn't exist yet.

packages/b2c-cli/src/commands/slas/client/list.ts

@@ -69,11 +69,16 @@ export default class SlasClientList extends SlasClientCommand<typeof SlasClientL
     });
 
     if (error) {
-      this.error(
-        t('commands.slas.client.list.error', 'Failed to list SLAS clients: {{message}}', {
-          message: formatApiError(error, response),
-        }),
-      );
+      const tenantExists = await this.checkTenantExists(slasClient, tenantId);
+      if (tenantExists) {
+        this.error(
+          t('commands.slas.client.list.error', 'Failed to list SLAS clients: {{message}}', {
+            message: formatApiError(error, response),
+          }),
+        );
+      }
+      // Tenant doesn't exist — no clients to list, fall through to empty handling
+      this.logger.debug({tenantId}, 'Tenant does not exist yet, returning empty client list');
     }
 
     const clients = ((data as {data?: Client[]})?.data ?? []).map((client) => normalizeClientResponse(client));

packages/b2c-cli/src/utils/slas/client.ts

@@ -107,23 +107,22 @@ export function formatApiError(error: unknown, response: Response): string {
  */
 export abstract class SlasClientCommand<T extends typeof Command> extends OAuthCommand<T> {
   /**
-   * Ensure tenant exists, creating it if necessary.
-   * This is required before creating SLAS clients.
+   * Check if a tenant exists.
+   * Returns true if the tenant exists, false if not found.
+   * Throws (via this.error) if an unexpected error occurs.
    */
-  protected async ensureTenantExists(slasClient: SlasClient, tenantId: string): Promise<void> {
-    // Try to get the tenant first
+  protected async checkTenantExists(slasClient: SlasClient, tenantId: string): Promise<boolean> {
     const {error, response} = await slasClient.GET('/tenants/{tenantId}', {
       params: {
         path: {tenantId},
       },
     });
 
-    // If tenant exists, we're done
     if (!error) {
-      return;
+      this.logger.debug({tenantId}, 'Tenant exists');
+      return true;
     }
 
-    // Check if this is a "tenant not found" error (SLAS returns 400 with TenantNotFoundException)
     const isTenantNotFound =
       response.status === 404 ||
       (response.status === 400 &&
@@ -132,13 +131,27 @@ export abstract class SlasClientCommand<T extends typeof Command> extends OAuthC
         'exception_name' in error &&
         (error as {exception_name?: string}).exception_name === 'TenantNotFoundException');
 
-    // If it's not a tenant-not-found error, something else went wrong
-    if (!isTenantNotFound) {
-      this.error(
-        t('commands.slas.client.create.tenantError', 'Failed to check tenant: {{message}}', {
-          message: formatApiError(error, response),
-        }),
-      );
+    if (isTenantNotFound) {
+      this.logger.debug({tenantId, status: response.status}, 'Tenant not found');
+      return false;
+    }
+
+    this.error(
+      t('commands.slas.client.create.tenantError', 'Failed to check tenant: {{message}}', {
+        message: formatApiError(error, response),
+      }),
+    );
+  }
+
+  /**
+   * Ensure tenant exists, creating it if necessary.
+   * This is required before creating SLAS clients.
+   */
+  protected async ensureTenantExists(slasClient: SlasClient, tenantId: string): Promise<void> {
+    const tenantExists = await this.checkTenantExists(slasClient, tenantId);
+
+    if (tenantExists) {
+      return;
     }
 
     // Tenant doesn't exist, create it with placeholder values

packages/b2c-cli/test/commands/slas/client/list.test.ts

@@ -49,12 +49,16 @@ describe('slas client list', () => {
     expect(result.clients).to.deep.equal([]);
   });
 
-  it('calls command.error on API error', async () => {
+  it('calls command.error on API error when tenant exists', async () => {
     const command: any = await createCommand({'tenant-id': 'abcd_123'}, {});
 
     sinon.stub(command, 'requireOAuthCredentials').returns(void 0);
 
-    const getStub = sinon.stub().resolves({data: undefined, error: {message: 'boom'}});
+    const getStub = sinon.stub();
+    // First call: list clients - returns error
+    getStub.onFirstCall().resolves({data: undefined, error: {message: 'boom'}, response: {status: 401}});
+    // Second call: check tenant - tenant exists
+    getStub.onSecondCall().resolves({data: {tenantId: 'abcd_123'}, error: undefined});
     sinon.stub(command, 'getSlasClient').returns({GET: getStub} as any);
 
     const errorStub = stubErrorToThrow(command);
@@ -66,4 +70,49 @@ describe('slas client list', () => {
       expect(errorStub.calledOnce).to.equal(true);
     }
   });
+
+  it('returns empty clients list when list errors and tenant does not exist (404)', async () => {
+    const command: any = await createCommand({'tenant-id': 'abcd_123'}, {});
+
+    sinon.stub(command, 'requireOAuthCredentials').returns(void 0);
+
+    const getStub = sinon.stub();
+    // First call: list clients - returns error
+    getStub.onFirstCall().resolves({data: undefined, error: {message: 'boom'}, response: {status: 401}});
+    // Second call: check tenant - tenant not found (404)
+    getStub.onSecondCall().resolves({error: {message: 'not found'}, response: {status: 404}});
+    sinon.stub(command, 'getSlasClient').returns({GET: getStub} as any);
+    sinon.stub(command, 'jsonEnabled').returns(true);
+
+    const errorStub = sinon.stub(command, 'error');
+
+    const result = await command.run();
+
+    expect(result.clients).to.deep.equal([]);
+    expect(errorStub.called).to.equal(false);
+  });
+
+  it('returns empty clients list when list errors and tenant does not exist (400 TenantNotFoundException)', async () => {
+    const command: any = await createCommand({'tenant-id': 'abcd_123'}, {});
+
+    sinon.stub(command, 'requireOAuthCredentials').returns(void 0);
+
+    const getStub = sinon.stub();
+    // First call: list clients - returns error
+    getStub.onFirstCall().resolves({data: undefined, error: {message: 'boom'}, response: {status: 401}});
+    // Second call: check tenant - tenant not found (400 + TenantNotFoundException)
+    getStub.onSecondCall().resolves({
+      error: {exception_name: 'TenantNotFoundException'},
+      response: {status: 400},
+    });
+    sinon.stub(command, 'getSlasClient').returns({GET: getStub} as any);
+    sinon.stub(command, 'jsonEnabled').returns(true);
+
+    const errorStub = sinon.stub(command, 'error');
+
+    const result = await command.run();
+
+    expect(result.clients).to.deep.equal([]);
+    expect(errorStub.called).to.equal(false);
+  });
 });