Add filterSensitiveLog method to Structure namespaces

smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/StructureGenerator.java

@@ -21,6 +21,7 @@
 import software.amazon.smithy.codegen.core.SymbolProvider;
 import software.amazon.smithy.codegen.core.SymbolReference;
 import software.amazon.smithy.model.Model;
+import software.amazon.smithy.model.shapes.MemberShape;
 import software.amazon.smithy.model.shapes.StructureShape;
 import software.amazon.smithy.model.traits.ErrorTrait;
 
@@ -168,8 +169,17 @@ private void renderErrorStructure() {
 
     private void renderStructureNamespace() {
         writer.addImport("isa", "__isa", "@aws-sdk/smithy-client");
+        writer.addImport("SENSITIVE_STRING", "SENSITIVE_STRING", "@aws-sdk/smithy-client");
         Symbol symbol = symbolProvider.toSymbol(shape);
         writer.openBlock("export namespace $L {", "}", symbol.getName(), () -> {
+            writer.openBlock("export const filterSensitiveLog = (obj: $L): any => ({", "})",
+                symbol.getName(),
+                () -> {
+                    StructuredMemberWriter config = new StructuredMemberWriter(
+                        model, symbolProvider, shape.getAllMembers().values());
+                    config.writeFilterSensitiveLog(writer, shape);
+                }
+            );
             writer.write("export const isa = (o: any): o is $L => __isa(o, $S);",
                 symbol.getName(), shape.getId().getName()
             );

smithy-typescript-codegen/src/main/java/software/amazon/smithy/typescript/codegen/StructuredMemberWriter.java

@@ -18,11 +18,16 @@
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Set;
+import software.amazon.smithy.codegen.core.CodegenException;
 import software.amazon.smithy.codegen.core.SymbolProvider;
 import software.amazon.smithy.model.Model;
+import software.amazon.smithy.model.shapes.CollectionShape;
+import software.amazon.smithy.model.shapes.MapShape;
 import software.amazon.smithy.model.shapes.MemberShape;
 import software.amazon.smithy.model.shapes.Shape;
+import software.amazon.smithy.model.shapes.StructureShape;
 import software.amazon.smithy.model.traits.IdempotencyTokenTrait;
+import software.amazon.smithy.model.traits.SensitiveTrait;
 
 /**
  * Generates objects, interfaces, enums, etc.
@@ -65,6 +70,140 @@ void writeMembers(TypeScriptWriter writer, Shape shape) {
         }
     }
 
+    /**
+     * Recursively writes filterSensitiveLog for CollectionShape.
+     */
+    void writeCollectionFilterSensitiveLog(TypeScriptWriter writer, MemberShape collectionMember) {
+        Shape memberShape = model.expectShape(collectionMember.getTarget());
+        if (memberShape instanceof StructureShape) {
+            // Call filterSensitiveLog on Structure.
+            writer.write("$T.filterSensitiveLog", symbolProvider.toSymbol(collectionMember));
+        } else if (memberShape instanceof CollectionShape) {
+            // Iterate over array items, and call array specific function on each member.
+            writer.openBlock("item => item.map(", ")",
+                () -> {
+                    MemberShape nestedCollectionMember = ((CollectionShape) memberShape).getMember();
+                    writeCollectionFilterSensitiveLog(writer, nestedCollectionMember);
+                }
+            );
+        } else if (memberShape instanceof MapShape) {
+            // Iterate over Object entries, and call reduce to repopulate map.
+            writer.openBlock("item => Object.entries(item).reduce(", ")",
+                () -> {
+                    MemberShape mapMember = ((MapShape) memberShape).getValue();
+                    writeMapFilterSensitiveLog(writer, mapMember);
+                }
+            );
+        } else {
+            // This path should not reach because of recursive isIterationRequired.
+            throw new CodegenException(String.format(
+                "CollectionFilterSensitiveLog attempted for %s while it was not required",
+                memberShape.getType()
+            ));
+            // For quick-fix in case of high severity issue:
+            // comment out the exception above and uncomment the line below.
+            // writer.write("item => item");
+        }
+    }
+
+    /**
+     * Recursively writes filterSensitiveLog for MapShape.
+     */
+    void writeMapFilterSensitiveLog(TypeScriptWriter writer, MemberShape mapMember) {
+        // Reducer is common to all shapes.
+        writer.openBlock("(acc: any, [key, value]: [string, $T]) => ({", "}), {}",
+            symbolProvider.toSymbol(mapMember),
+            () -> {
+                writer.write("...acc,");
+                Shape memberShape = model.expectShape(mapMember.getTarget());
+                if (memberShape instanceof StructureShape) {
+                    // Call filterSensitiveLog on Structure.
+                    writer.write("[key]: $T.filterSensitiveLog(value),",
+                        symbolProvider.toSymbol(mapMember));
+                } else if (memberShape instanceof CollectionShape) {
+                    writer.openBlock("[key]: value.map(", "),",
+                        () -> {
+                            MemberShape collectionMember = ((CollectionShape) memberShape).getMember();
+                            writeCollectionFilterSensitiveLog(writer, collectionMember);
+                        }
+                    );
+                } else if (memberShape instanceof MapShape) {
+                    writer.openBlock("[key]: Object.entries(value).reduce(", "),",
+                        () -> {
+                            MemberShape nestedMapMember = ((MapShape) memberShape).getValue();
+                            writeMapFilterSensitiveLog(writer, nestedMapMember);
+                        }
+                    );
+                } else {
+                    // This path should not reach because of recursive isIterationRequired.
+                    throw new CodegenException(String.format(
+                        "MapFilterSensitiveLog attempted for %s while it was not required",
+                        memberShape.getType()
+                    ));
+                    // For quick-fix in case of high severity issue:
+                    // comment out the exception above and uncomment the line below.
+                    // writer.write("[key]: value,");
+                }
+            }
+        );
+    }
+
+    void writeFilterSensitiveLog(TypeScriptWriter writer, Shape shape) {
+        writer.write("...obj,");
+        for (MemberShape member : members) {
+            Shape memberShape = model.expectShape(member.getTarget());
+            String memberName = TypeScriptUtils.sanitizePropertyName(symbolProvider.toMemberName(member));
+            if (member.getMemberTrait(model, SensitiveTrait.class).isPresent()) {
+                // member is Sensitive, hide the value.
+                writer.write("...(obj.$1L && { $1L: SENSITIVE_STRING }),", memberName);
+            } else if (memberShape instanceof StructureShape) {
+                // Call filterSensitiveLog on Structure.
+                writer.write("...(obj.$1L && { $1L: $2T.filterSensitiveLog(obj.$1L)}),",
+                        memberName, symbolProvider.toSymbol(member));
+            } else if (memberShape instanceof CollectionShape) {
+                MemberShape collectionMember = ((CollectionShape) memberShape).getMember();
+                if (isIterationRequired(collectionMember)) {
+                    // Iterate over array items, and call array specific function on each member.
+                    writer.openBlock("...(obj.$1L && { $1L: obj.$1L.map(", ")}),", memberName,
+                        () -> {
+                            writeCollectionFilterSensitiveLog(writer, collectionMember);
+                        }
+                    );
+                }
+            } else if (memberShape instanceof MapShape) {
+                MemberShape mapMember = ((MapShape) memberShape).getValue();
+                if (isIterationRequired(mapMember)) {
+                    // Iterate over Object entries, and call reduce to repopulate map.
+                    writer.openBlock("...(obj.$1L && { $1L: Object.entries(obj.$1L).reduce(", ")}),", memberName,
+                        () -> {
+                            writeMapFilterSensitiveLog(writer, mapMember);
+                        }
+                    );
+                }
+            }
+        }
+    }
+
+    /**
+     * Identifies if iteration is required on MemberShape.
+     * 
+     * @param memberShape a {@link MemberShape} to check for iteration required.
+     * @return Returns true if the iteration is required on memberShape.
+     */
+    private boolean isIterationRequired(MemberShape memberShape) {
+        Shape targetShape = model.expectShape(memberShape.getTarget());
+        if (targetShape instanceof StructureShape) {
+            return true;
+        } if (targetShape instanceof CollectionShape) {
+            MemberShape collectionMember = ((CollectionShape) targetShape).getMember();
+            return isIterationRequired(collectionMember);
+        } else if (targetShape instanceof MapShape) {
+            MemberShape mapMember = ((MapShape) targetShape).getValue();
+            return isIterationRequired(mapMember);
+        }
+        return false;
+    }
+
     /**
      * Identifies if a member should be required on the generated interface.
      *