fix(smithy-client): instanceof support for ServiceException class (#1490)

* fix(smithy-client): instanceof support for ServiceException class

* chore(changeset): changeset

* chore(smithy-client): formatting fix

* fix(smithy-client): update in line with the assertion table

* chore(smithy-client): formatting fix

* chore(smithy-client): explicit fallback to prototype check if a name doesn't exist

Author: siddsriv

.changeset/yellow-hats-live.md

@@ -0,0 +1,5 @@
+---
+"@smithy/smithy-client": minor
+---
+
+adds support for instanceof operator for ServiceException class

packages/smithy-client/src/exceptions.spec.ts

@@ -34,39 +34,120 @@ it("ExceptionOptionType allows specifying message", () => {
   expect(exception.code).toBe("code");
 });
 
-describe("ServiceException type checking", () => {
-  const error = new ServiceException({
-    name: "Error",
-    $fault: "client",
-    $metadata: {},
+describe("Exception Hierarchy Tests", () => {
+  // test classes to represent the hierarchy
+  class ClientServiceException extends ServiceException {
+    constructor() {
+      super({
+        name: "ClientServiceException",
+        $fault: "client",
+        $metadata: {},
+      });
+      Object.setPrototypeOf(this, ClientServiceException.prototype);
+    }
+  }
+
+  class ModeledClientServiceException extends ClientServiceException {
+    constructor() {
+      super();
+      this.name = "ModeledClientServiceException";
+      Object.setPrototypeOf(this, ModeledClientServiceException.prototype);
+    }
+  }
+
+  describe("Empty Object Tests", () => {
+    it("empty object should not be instanceof any exception", () => {
+      expect({} instanceof Error).toBe(false);
+      expect({} instanceof ServiceException).toBe(false);
+      expect({} instanceof ClientServiceException).toBe(false);
+      expect({} instanceof ModeledClientServiceException).toBe(false);
+    });
   });
 
-  const duckTyped = {
-    $fault: "server",
-    $metadata: {},
-  };
+  describe("Error Instance Tests", () => {
+    const error = new Error();
+    it("Error instance should only be instanceof Error", () => {
+      expect(error instanceof Error).toBe(true);
+      expect(error instanceof ServiceException).toBe(false);
+      expect(error instanceof ClientServiceException).toBe(false);
+      expect(error instanceof ModeledClientServiceException).toBe(false);
+    });
+  });
+
+  describe("ServiceException Instance Tests", () => {
+    const serviceException = new ServiceException({
+      name: "ServiceException",
+      $fault: "client",
+      $metadata: {},
+    });
+
+    it("ServiceException instance should be instanceof Error and ServiceException", () => {
+      expect(serviceException instanceof Error).toBe(true);
+      expect(serviceException instanceof ServiceException).toBe(true);
+      expect(serviceException instanceof ClientServiceException).toBe(false);
+      expect(serviceException instanceof ModeledClientServiceException).toBe(false);
+    });
+  });
+
+  describe("ClientServiceException Instance Tests", () => {
+    const clientException = new ClientServiceException();
+    it("ClientServiceException instance should be instanceof Error, ServiceException, and ClientServiceException", () => {
+      expect(clientException instanceof Error).toBe(true);
+      expect(clientException instanceof ServiceException).toBe(true);
+      expect(clientException instanceof ClientServiceException).toBe(true);
+      expect(clientException instanceof ModeledClientServiceException).toBe(false);
+    });
+  });
+
+  describe("ModeledClientServiceException Instance Tests", () => {
+    const modeledException = new ModeledClientServiceException();
+    it("ModeledClientServiceException instance should be instanceof Error, ServiceException, ClientServiceException, and ModeledClientServiceException", () => {
+      expect(modeledException instanceof Error).toBe(true);
+      expect(modeledException instanceof ServiceException).toBe(true);
+      expect(modeledException instanceof ClientServiceException).toBe(true);
+      expect(modeledException instanceof ModeledClientServiceException).toBe(true);
+    });
+  });
 
-  describe("isInstance", () => {
-    it("should return true for ServiceException instances", () => {
-      expect(ServiceException.isInstance(error)).toBe(true);
+  describe("Duck-Typed Object Tests", () => {
+    it("object with only name should not be instanceof any exception", () => {
+      const obj = { name: "Error" };
+      expect(obj instanceof Error).toBe(false);
+      expect(obj instanceof ServiceException).toBe(false);
+      expect(obj instanceof ClientServiceException).toBe(false);
+      expect(obj instanceof ModeledClientServiceException).toBe(false);
     });
 
-    it("should return true for duck-typed objects", () => {
-      expect(ServiceException.isInstance(duckTyped)).toBe(true);
+    it("object with only $-props should be instanceof ServiceException", () => {
+      const obj = { $fault: "client" as const, $metadata: {} };
+      expect(obj instanceof Error).toBe(false);
+      expect(obj instanceof ServiceException).toBe(true);
+      expect(obj instanceof ClientServiceException).toBe(false);
+      expect(obj instanceof ModeledClientServiceException).toBe(false);
     });
 
-    it("should return false for null or undefined", () => {
-      expect(ServiceException.isInstance(null)).toBe(false);
-      expect(ServiceException.isInstance(undefined)).toBe(false);
+    it("object with ServiceException name and $-props should be instanceof ServiceException only", () => {
+      const obj = { name: "ServiceException", $fault: "client" as const, $metadata: {} };
+      expect(obj instanceof Error).toBe(false);
+      expect(obj instanceof ServiceException).toBe(true);
+      expect(obj instanceof ClientServiceException).toBe(false);
+      expect(obj instanceof ModeledClientServiceException).toBe(false);
     });
 
-    it("should return false for invalid $fault values", () => {
-      expect(ServiceException.isInstance({ $fault: "invalid", $metadata: {} })).toBe(false);
+    it("object with ClientServiceException name and $-props should be instanceof ServiceException and ClientServiceException", () => {
+      const obj = { name: "ClientServiceException", $fault: "client" as const, $metadata: {} };
+      expect(obj instanceof Error).toBe(false);
+      expect(obj instanceof ServiceException).toBe(true);
+      expect(obj instanceof ClientServiceException).toBe(true);
+      expect(obj instanceof ModeledClientServiceException).toBe(false);
     });
 
-    it("should return false for missing properties", () => {
-      expect(ServiceException.isInstance({ $fault: "client" })).toBe(false);
-      expect(ServiceException.isInstance({ $metadata: {} })).toBe(false);
+    it("object with ModeledClientServiceException name and $-props should be instanceof ServiceException and ModeledClientServiceException", () => {
+      const obj = { name: "ModeledClientServiceException", $fault: "client" as const, $metadata: {} };
+      expect(obj instanceof Error).toBe(false);
+      expect(obj instanceof ServiceException).toBe(true);
+      expect(obj instanceof ClientServiceException).toBe(false);
+      expect(obj instanceof ModeledClientServiceException).toBe(true);
     });
   });
 });

packages/smithy-client/src/exceptions.ts

@@ -32,7 +32,7 @@ export class ServiceException extends Error implements SmithyException, Metadata
 
   constructor(options: ServiceExceptionOptions) {
     super(options.message);
-    Object.setPrototypeOf(this, ServiceException.prototype);
+    Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype);
     this.name = options.name;
     this.$fault = options.$fault;
     this.$metadata = options.$metadata;
@@ -50,6 +50,30 @@ export class ServiceException extends Error implements SmithyException, Metadata
       (candidate.$fault === "client" || candidate.$fault === "server")
     );
   }
+
+  /**
+   * Custom instanceof check to support the operator for ServiceException base class
+   */
+  public static [Symbol.hasInstance](instance: unknown): boolean {
+    // Handle null/undefined
+    if (!instance) return false;
+    const candidate = instance as ServiceException;
+    // For ServiceException, check only $-props
+    if (this === ServiceException) {
+      return ServiceException.isInstance(instance);
+    }
+    // For subclasses, check both prototype chain and name match
+    // Note: instance must be ServiceException first (having $-props)
+    if (ServiceException.isInstance(instance)) {
+      // Only do name comparison if both sides have non-empty names
+      if (candidate.name && this.name) {
+        return this.prototype.isPrototypeOf(instance) || candidate.name === this.name;
+      }
+      // Otherwise fall back to just prototype check
+      return this.prototype.isPrototypeOf(instance);
+    }
+    return false;
+  }
 }
 
 /**