Merge pull request #1 from XiNiHa/feat/transform-directives

Author: benjie

src/cli.ts

@@ -1,21 +1,22 @@
 import {
   buildSchema,
+  GraphQLFieldConfig,
   GraphQLFieldConfigMap,
-  GraphQLFieldMap,
   GraphQLInterfaceType,
   GraphQLList,
   GraphQLNamedType,
   GraphQLNonNull,
   GraphQLObjectType,
+  GraphQLOutputType,
   GraphQLSchema,
   GraphQLSemanticNonNull,
   GraphQLType,
   GraphQLUnionType,
+  Kind,
   printSchema,
   validateSchema,
 } from "graphql";
 import type { Maybe } from "graphql/jsutils/Maybe";
-import { ObjMap } from "graphql/jsutils/ObjMap";
 import { readFile, writeFile } from "node:fs/promises";
 import { parseArgs } from "node:util";
 
@@ -59,6 +60,7 @@ export async function main(toStrict = false) {
     types: config.types
       .filter((t) => !t.name.startsWith("__"))
       .map((t) => convertType(t)),
+    directives: config.directives.filter((d) => d.name !== "semanticNonNull"),
   });
 
   const newSdl = printSchema(derivedSchema);
@@ -72,13 +74,16 @@ function makeConvertType(toStrict: boolean) {
   function convertFields(fields: GraphQLFieldConfigMap<any, any>) {
     return () => {
       return Object.fromEntries(
-        Object.entries(fields).map(([fieldName, spec]) => [
-          fieldName,
-          {
-            ...spec,
-            type: convertType(spec.type),
-          },
-        ]),
+        Object.entries(fields).map(([fieldName, inSpec]) => {
+          const spec = applySemanticNonNullDirective(inSpec);
+          return [
+            fieldName,
+            {
+              ...spec,
+              type: convertType(spec.type),
+            },
+          ];
+        }),
       ) as any;
     };
   }
@@ -161,3 +166,71 @@ function makeConvertType(toStrict: boolean) {
 
   return convertType;
 }
+
+/**
+ * Takes a GraphQL field config and checks to see if the `@semanticNonNull`
+ * directive was applied; if so, converts to a field config using explicit
+ * GraphQLSemanticNonNull wrapper types instead.
+ *
+ * @see {@url https://www.apollographql.com/docs/kotlin/advanced/nullability/#semanticnonnull}
+ */
+function applySemanticNonNullDirective(
+  spec: GraphQLFieldConfig<any, any, any>,
+): GraphQLFieldConfig<any, any, any> {
+  const directive = spec.astNode?.directives?.find(
+    (d) => d.name.value === "semanticNonNull",
+  );
+  if (!directive) {
+    return spec;
+  }
+  const levelsArg = directive.arguments?.find((a) => a.name.value === "levels");
+  const levels =
+    levelsArg?.value?.kind === Kind.LIST
+      ? levelsArg.value.values
+          .filter((v) => v.kind === Kind.INT)
+          .map((v) => Number(v.value))
+      : [0];
+  function recurse(type: GraphQLOutputType, level: number): GraphQLOutputType {
+    if (type instanceof GraphQLSemanticNonNull) {
+      // Strip semantic-non-null types; this should never happen but if someone
+      // uses both semantic-non-null and the `@semanticNonNull` directive, we
+      // want the directive to win (I guess?)
+      return recurse(type.ofType, level);
+    } else if (type instanceof GraphQLNonNull) {
+      const inner = recurse(type.ofType, level);
+      if (levels.includes(level)) {
+        // Semantic non-null from `inner` replaces our GrpahQLNonNull wrapper
+        return inner;
+      } else {
+        // Keep non-null wrapper; no semantic-non-null was added to `inner`
+        return new GraphQLNonNull(inner);
+      }
+    } else if (type instanceof GraphQLList) {
+      const inner = new GraphQLList(recurse(type.ofType, level + 1));
+      if (levels.includes(level)) {
+        return new GraphQLSemanticNonNull(inner);
+      } else {
+        return inner;
+      }
+    } else {
+      if (levels.includes(level)) {
+        return new GraphQLSemanticNonNull(type);
+      } else {
+        return type;
+      }
+    }
+  }
+
+  return {
+    ...spec,
+    type: recurse(spec.type, 0),
+    astNode: spec.astNode
+      ? {
+          ...spec.astNode,
+          directives: spec.astNode.directives?.filter(
+            (d) => d.name.value !== "semanticNonNull",
+          ),
+        }
+      : undefined,
+  };
+}