swift: Fix codegen with empty input objects / arrays

The codegen was omitting the `[:]` and `[]` tokens entirely.

Fixes apollographql/apollo-ios#838

Author: lilyball

CHANGELOG.md

@@ -9,7 +9,7 @@
 - `apollo-codegen-scala`
   - <First `apollo-codegen-scala` related entry goes here>
 - `apollo-codegen-swift`
-  - <First `apollo-codegen-swift` related entry goes here>
+  - Fix code generation for empty input objects / arrays [#1589](https://github.com/apollographql/apollo-tooling/pull/1589)
 - `apollo-codegen-typescript`
   - <First `apollo-codegen-typescript` related entry goes here>
 - `apollo-env`

packages/apollo-codegen-swift/src/__tests__/codeGeneration.ts

@@ -1,4 +1,5 @@
 import {
+  buildSchema,
   parse,
   GraphQLNonNull,
   GraphQLString,
@@ -754,5 +755,70 @@ describe("Swift code generation", () => {
         '["episode": "JEDI", "review": ["stars": 2, "commentary": GraphQLVariable("commentary"), "favorite_color": ["red": GraphQLVariable("red"), "blue": 100, "green": 50]]]'
       );
     });
+
+    it("should handle empty input objects", () => {
+      // The existing schemas don't contain any input objects with all nullable types.
+      // Extending the schema in a call to `compile` doesn't seem to work.
+      // So instead we'll just build our own.
+      const schema = buildSchema(`
+        schema {
+          query: Query
+        }
+        type Query {
+          foo(input: FooInput!): Int
+        }
+        input FooInput {
+          id: ID
+        }
+      `);
+      const document = parse(`
+        query FieldArgumentsWithEmptyInputObject {
+          foo(input: {}) {
+            id
+          }
+        }
+      `);
+      const context = compileToIR(schema, document);
+      generator.context = context;
+
+      const { operations } = context;
+      const fieldArguments = (operations["FieldArgumentsWithEmptyInputObject"]
+        .selectionSet.selections[0] as Field).args as Argument[];
+      const dictionaryLiteral = generator.helpers.dictionaryLiteralForFieldArguments(
+        fieldArguments
+      ).source;
+
+      expect(dictionaryLiteral).toBe('["input": [:]]');
+    });
+
+    it("should handle empty input arrays", () => {
+      // As with the previous test, we need to build our own schema.
+      const schema = buildSchema(`
+        schema {
+          query: Query
+        }
+        type Query {
+          foo(input: [Int!]!): Int
+        }
+      `);
+      const document = parse(`
+        query FieldArgumentsWithEmptyInputArray {
+          foo(input: []) {
+            id
+          }
+        }
+      `);
+      const context = compileToIR(schema, document);
+      generator.context = context;
+
+      const { operations } = context;
+      const fieldArguments = (operations["FieldArgumentsWithEmptyInputArray"]
+        .selectionSet.selections[0] as Field).args as Argument[];
+      const dictionaryLiteral = generator.helpers.dictionaryLiteralForFieldArguments(
+        fieldArguments
+      ).source;
+
+      expect(dictionaryLiteral).toBe('["input": []]');
+    });
   });
 });

packages/apollo-codegen-swift/src/helpers.ts

@@ -260,23 +260,27 @@ export class Helpers {
           value.variableName
         )})`;
       } else if (Array.isArray(value)) {
-        return SwiftSource.wrap(
-          swift`[`,
-          SwiftSource.join(value.map(expressionFromValue), ", "),
-          swift`]`
+        return (
+          SwiftSource.wrap(
+            swift`[`,
+            SwiftSource.join(value.map(expressionFromValue), ", "),
+            swift`]`
+          ) || swift`[]`
         );
       } else if (typeof value === "object") {
-        return SwiftSource.wrap(
-          swift`[`,
-          SwiftSource.join(
-            Object.entries(value).map(([key, value]) => {
-              return swift`${SwiftSource.string(key)}: ${expressionFromValue(
-                value
-              )}`;
-            }),
-            ", "
-          ) || ":",
-          swift`]`
+        return (
+          SwiftSource.wrap(
+            swift`[`,
+            SwiftSource.join(
+              Object.entries(value).map(([key, value]) => {
+                return swift`${SwiftSource.string(key)}: ${expressionFromValue(
+                  value
+                )}`;
+              }),
+              ", "
+            ),
+            swift`]`
+          ) || swift`[:]`
         );
       } else if (typeof value === "string") {
         return SwiftSource.string(value);
@@ -285,17 +289,19 @@ export class Helpers {
       }
     }
 
-    return SwiftSource.wrap(
-      swift`[`,
-      SwiftSource.join(
-        args.map(arg => {
-          return swift`${SwiftSource.string(arg.name)}: ${expressionFromValue(
-            arg.value
-          )}`;
-        }),
-        ", "
-      ) || ":",
-      swift`]`
+    return (
+      SwiftSource.wrap(
+        swift`[`,
+        SwiftSource.join(
+          args.map(arg => {
+            return swift`${SwiftSource.string(arg.name)}: ${expressionFromValue(
+              arg.value
+            )}`;
+          }),
+          ", "
+        ),
+        swift`]`
+      ) || swift`[:]`
     );
   }
 

packages/apollo-codegen-swift/src/language.ts

@@ -276,30 +276,29 @@ export class SwiftSource {
   }
 
   /**
-   * If maybeSource is not null or empty, then wrap with start and end, otherwise return an empty
-   * string.
+   * If maybeSource is not undefined or empty, then wrap with start and end, otherwise return
+   * undefined.
    *
-   * This is just a wrapper for `wrap()` from apollo-codegen-core/lib/utilities/printing.
+   * This is largely just a wrapper for `wrap()` from apollo-codegen-core/lib/utilities/printing.
    */
   static wrap(
     start: SwiftSource,
     maybeSource?: SwiftSource,
     end?: SwiftSource
-  ): SwiftSource {
-    return new SwiftSource(
-      _wrap(
-        start.source,
-        maybeSource !== undefined ? maybeSource.source : undefined,
-        end !== undefined ? end.source : undefined
-      )
+  ): SwiftSource | undefined {
+    const result = _wrap(
+      start.source,
+      maybeSource !== undefined ? maybeSource.source : undefined,
+      end !== undefined ? end.source : undefined
     );
+    return result ? new SwiftSource(result) : undefined;
   }
 
   /**
-   * Given maybeArray, return an empty string if it is null or empty, otherwise return all items
+   * Given maybeArray, return undefined if it is undefined or empty, otherwise return all items
    * together separated by separator if provided.
    *
-   * This is just a wrapper for `join()` from apollo-codegen-core/lib/utilities/printing.
+   * This is largely just a wrapper for `join()` from apollo-codegen-core/lib/utilities/printing.
    *
    * @param separator The separator to put between elements. This is typed as `string` with the
    * expectation that it's generally something like `', '` but if it contains identifiers it should
@@ -308,8 +307,9 @@ export class SwiftSource {
   static join(
     maybeArray?: (SwiftSource | undefined)[],
     separator?: string
-  ): SwiftSource {
-    return new SwiftSource(_join(maybeArray, separator));
+  ): SwiftSource | undefined {
+    const result = _join(maybeArray, separator);
+    return result ? new SwiftSource(result) : undefined;
   }
 }