graphql-jerky 1.0.8 → 1.0.9

package/README.md

@@ -34,6 +34,27 @@ in the same directory.
 A path to a directory or file can be passed as the first parameter to limit to
 scope of the search.
 
+### Type extensions
+
+Type extensions (`extend type`, `extend interface`, `extend union`,
+`extend enum`, `extend input` and `extend scalar`) are merged into the type
+that they extend. The extension and the definition can be in different files,
+in any order.
+
+```gql
+# user.graphql
+type Query {
+  me: User
+}
+
+# post.graphql
+extend type Query {
+  posts: [Post!]!
+}
+```
+
+An extension of a type that is not defined causes an error.
+
 ### Options
 
 #### --graphql

package/build/lib.cjs

@@ -340,14 +340,8 @@ function renderAstNode(astNode) {
 }
 function isBuiltInDirective(name) {
     // https://spec.graphql.org/draft/#sec-Type-System.Directives.Built-in-Directives
-    switch (name) {
-        case "deprecated":
-        case "skip":
-        case "include":
-        case "specifiedBy":
-            return true;
-    }
-    return false;
+    // Use the list from graphql, because new versions add directives (for example, @oneOf).
+    return graphql.specifiedDirectives.some((d) => d.name === name);
 }
 function truthify(arr) {
     return arr.filter(Boolean);
@@ -1613,6 +1607,9 @@ function setTraceToSchema(err, name, loc) {
     }
     return err;
 }
+function isMergableDefinitionNode(node) {
+    return graphql.isTypeDefinitionNode(node) || node.kind === graphql.Kind.DIRECTIVE_DEFINITION;
+}
 function namedNodesDict(nodes = []) {
     return Object.fromEntries(nodes.map((node) => [node.name.value, node]));
 }
@@ -1726,7 +1723,7 @@ function mergeFieldDefinitionNodes(name, a, b) {
                 console.warn(`WARNING: there is more than one declaration for ${name}.${f.name.value}${traceLine(f.loc)}${traceLine(prev.loc, "previously ")}\n`);
                 fields[f.name.value] = {
                     ...prev,
-                    directives: mergeDirectiveNodes(`${name}.${f.name.value}`, prev.directives, f.directives),
+                    directives: mergeDirectiveNodes(prev.directives, f.directives),
                 };
             }
             else {
@@ -1751,7 +1748,7 @@ function mergeInputValueDefinitionNodes(name, a, b) {
                 console.warn(`WARNING: there is more than one declaration for ${name}.${f.name.value}${traceLine(f.loc)}${traceLine(prev.loc, "previously ")}\n`);
                 fields[f.name.value] = {
                     ...prev,
-                    directives: mergeDirectiveNodes(`${name}.${f.name.value}`, prev.directives, f.directives),
+                    directives: mergeDirectiveNodes(prev.directives, f.directives),
                 };
             }
             else {
@@ -1770,18 +1767,19 @@ function mergeNamedNodes(a, b) {
     }
     return Object.values(nodes);
 }
-function mergeDirectiveNodes(name, a, b) {
-    const directives = namedNodesDict(a);
-    if (b) {
-        for (const d of b) {
-            if (d.name.value in directives &&
-                !isArgumentNodesEqual(directives[d.name.value].arguments, d.arguments)) {
-                throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate directive with different arguments: ${name} @${d.name.value}`), `${name} @${d.name.value}`, d.loc);
-            }
-            directives[d.name.value] = d;
-        }
-    }
-    return Object.values(directives);
+function mergeDirectiveNodes(a, b) {
+    // Keep each occurrence, because a repeatable directive can occur more than
+    // once. Skip only an occurrence that is identical to one that is already
+    // applied. buildASTSchema rejects a non-repeatable directive that occurs
+    // more than once.
+    const directives = Array.from(a ?? []);
+    for (const d of b ?? []) {
+        if (!directives.some((prev) => prev.name.value === d.name.value &&
+            isArgumentNodesEqual(prev.arguments, d.arguments))) {
+            directives.push(d);
+        }
+    }
+    return directives;
 }
 function mergeScalarTypeDefinitionNodes(a, b) {
     if (a.name.value !== b.name.value) {
@@ -1789,8 +1787,10 @@ function mergeScalarTypeDefinitionNodes(a, b) {
     }
     return {
         kind: graphql.Kind.SCALAR_TYPE_DEFINITION,
+        loc: a.loc,
         name: a.name,
-        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        description: a.description || b.description,
+        directives: mergeDirectiveNodes(a.directives, b.directives),
     };
 }
 function mergeObjectTypeDefinitionNodes(a, b) {
@@ -1800,7 +1800,7 @@ function mergeObjectTypeDefinitionNodes(a, b) {
         name: a.name,
         description: a.description || b.description,
         interfaces: mergeNamedNodes(a.interfaces, b.interfaces),
-        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        directives: mergeDirectiveNodes(a.directives, b.directives),
         fields: mergeFieldDefinitionNodes(a.name.value, a.fields, b.fields),
     };
 }
@@ -1811,7 +1811,7 @@ function mergeInterfaceTypeDefinitionNodes(a, b) {
         name: a.name,
         description: a.description || b.description,
         interfaces: mergeNamedNodes(a.interfaces, b.interfaces),
-        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        directives: mergeDirectiveNodes(a.directives, b.directives),
         fields: mergeFieldDefinitionNodes(a.name.value, a.fields, b.fields),
     };
 }
@@ -1821,7 +1821,7 @@ function mergeUnionTypeDefinitionNodes(a, b) {
         loc: a.loc,
         name: a.name,
         description: a.description || b.description,
-        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        directives: mergeDirectiveNodes(a.directives, b.directives),
         types: mergeNamedNodes(a.types, b.types),
     };
 }
@@ -1830,7 +1830,7 @@ function mergeEnumTypeDefinitionNodes(a, b) {
     if (b) {
         for (const v of b.values || []) {
             if (v.name.value in values) {
-                throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate enum value: ${v.name.value}.${v.name.value}`), `${v.name.value}.${v.name.value}`, v.loc);
+                throw setTraceToSchema(new graphql.GraphQLError(`Cannot merge duplicate enum value: ${a.name.value}.${v.name.value}`), `${a.name.value}.${v.name.value}`, v.loc);
             }
             values[v.name.value] = v;
         }
@@ -1840,7 +1840,7 @@ function mergeEnumTypeDefinitionNodes(a, b) {
         loc: a.loc,
         name: a.name,
         description: a.description || b.description,
-        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        directives: mergeDirectiveNodes(a.directives, b.directives),
         values: Object.values(values),
     };
 }
@@ -1850,26 +1850,74 @@ function mergeInputObjectTypeDefinitionNodes(a, b) {
         loc: a.loc,
         name: a.name,
         description: a.description || b.description,
-        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        directives: mergeDirectiveNodes(a.directives, b.directives),
         fields: mergeInputValueDefinitionNodes(a.name.value, a.fields, b.fields),
     };
 }
+const EXTENSION_DEFINITION_KINDS = {
+    [graphql.Kind.SCALAR_TYPE_EXTENSION]: graphql.Kind.SCALAR_TYPE_DEFINITION,
+    [graphql.Kind.OBJECT_TYPE_EXTENSION]: graphql.Kind.OBJECT_TYPE_DEFINITION,
+    [graphql.Kind.INTERFACE_TYPE_EXTENSION]: graphql.Kind.INTERFACE_TYPE_DEFINITION,
+    [graphql.Kind.UNION_TYPE_EXTENSION]: graphql.Kind.UNION_TYPE_DEFINITION,
+    [graphql.Kind.ENUM_TYPE_EXTENSION]: graphql.Kind.ENUM_TYPE_DEFINITION,
+    [graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION]: graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+};
+function mergeTypeDefinitionNodes(a, b) {
+    switch (b.kind) {
+        case graphql.Kind.SCALAR_TYPE_DEFINITION:
+            return mergeScalarTypeDefinitionNodes(a, b);
+        case graphql.Kind.OBJECT_TYPE_DEFINITION:
+            return mergeObjectTypeDefinitionNodes(a, b);
+        case graphql.Kind.INTERFACE_TYPE_DEFINITION:
+            return mergeInterfaceTypeDefinitionNodes(a, b);
+        case graphql.Kind.UNION_TYPE_DEFINITION:
+            return mergeUnionTypeDefinitionNodes(a, b);
+        case graphql.Kind.ENUM_TYPE_DEFINITION:
+            return mergeEnumTypeDefinitionNodes(a, b);
+        case graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION:
+            return mergeInputObjectTypeDefinitionNodes(a, b);
+    }
+}
+function applyTypeExtensionNode(definitions, extension) {
+    const name = extension.name.value;
+    const definition = definitions[name];
+    if (!definition) {
+        throw setTraceToSchema(new graphql.GraphQLError(`Cannot extend type that is not defined: ${name}`), name, extension.loc);
+    }
+    const kind = EXTENSION_DEFINITION_KINDS[extension.kind];
+    if (definition.kind !== kind) {
+        throw setTraceToSchema(new graphql.GraphQLError(`Cannot extend ${definition.kind} with ${extension.kind}: ${name}`), name, extension.loc);
+    }
+    // An extension has the same shape as its definition, without a description.
+    const merged = mergeTypeDefinitionNodes(definition, {
+        ...extension,
+        kind,
+        directives: undefined,
+    });
+    // The directives of an extension are added to the directives of the type.
+    // buildASTSchema rejects a non-repeatable directive that occurs more than
+    // once.
+    definitions[name] = {
+        ...merged,
+        directives: [
+            ...(definition.directives ?? []),
+            ...(extension.directives ?? []),
+        ],
+    };
+}
 function mergeDocumentNodes(documentNodes) {
     const definitions = {};
+    const extensions = [];
     for (const documentNode of documentNodes) {
         for (const definition of documentNode.definitions) {
-            switch (definition.kind) {
-                case graphql.Kind.SCHEMA_DEFINITION:
-                case graphql.Kind.SCHEMA_EXTENSION:
-                case graphql.Kind.OPERATION_DEFINITION:
-                case graphql.Kind.FRAGMENT_DEFINITION:
-                case graphql.Kind.SCALAR_TYPE_EXTENSION:
-                case graphql.Kind.OBJECT_TYPE_EXTENSION:
-                case graphql.Kind.INTERFACE_TYPE_EXTENSION:
-                case graphql.Kind.UNION_TYPE_EXTENSION:
-                case graphql.Kind.ENUM_TYPE_EXTENSION:
-                case graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION:
-                    throw new Error(`unexpected definition kind: ${definition.kind}`);
+            if (graphql.isTypeExtensionNode(definition)) {
+                // Apply extensions after all definitions are known, because an
+                // extension can occur before the definition that it extends.
+                extensions.push(definition);
+                continue;
+            }
+            if (!isMergableDefinitionNode(definition)) {
+                throw new Error(`unexpected definition kind: ${definition.kind}`);
             }
             const prevDefinition = definitions[definition.name.value];
             if (!prevDefinition) {
@@ -1887,30 +1935,12 @@ function mergeDocumentNodes(documentNodes) {
                 prevDefinition.description.value !== definition.description.value) {
                 console.warn(`WARNING: different descriptions for type ${prevDefinition.name.value}: ${JSON.stringify(prevDefinition.description.value)} and ${JSON.stringify(definition.description.value)}${traceLine(definition.description.loc)}${traceLine(prevDefinition.description.loc, "previously ")}\n`);
             }
-            switch (definition.kind) {
-                case graphql.Kind.SCALAR_TYPE_DEFINITION:
-                    definitions[definition.name.value] = mergeScalarTypeDefinitionNodes(prevDefinition, definition);
-                    break;
-                case graphql.Kind.OBJECT_TYPE_DEFINITION:
-                    definitions[definition.name.value] = mergeObjectTypeDefinitionNodes(prevDefinition, definition);
-                    break;
-                case graphql.Kind.INTERFACE_TYPE_DEFINITION:
-                    definitions[definition.name.value] =
-                        mergeInterfaceTypeDefinitionNodes(prevDefinition, definition);
-                    break;
-                case graphql.Kind.UNION_TYPE_DEFINITION:
-                    definitions[definition.name.value] = mergeUnionTypeDefinitionNodes(prevDefinition, definition);
-                    break;
-                case graphql.Kind.ENUM_TYPE_DEFINITION:
-                    definitions[definition.name.value] = mergeEnumTypeDefinitionNodes(prevDefinition, definition);
-                    break;
-                case graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-                    definitions[definition.name.value] =
-                        mergeInputObjectTypeDefinitionNodes(prevDefinition, definition);
-                    break;
-            }
+            definitions[definition.name.value] = mergeTypeDefinitionNodes(prevDefinition, definition);
         }
     }
+    for (const extension of extensions) {
+        applyTypeExtensionNode(definitions, extension);
+    }
     return {
         kind: graphql.Kind.DOCUMENT,
         loc: documentNodes[0].loc,

package/build/lib.mjs

@@ -1,6 +1,6 @@
 import path, { resolve, basename, extname, join } from 'node:path';
 import { pathToFileURL, fileURLToPath } from 'node:url';
-import { GraphQLNonNull, GraphQLList, GraphQLScalarType, GraphQLEnumType, GraphQLDirective, Kind, GraphQLObjectType, getNamedType, getNullableType, GraphQLInterfaceType, GraphQLUnionType, GraphQLInputObjectType, DirectiveLocation, GraphQLError, parse as parse$3, Source, buildASTSchema, validateSchema } from 'graphql';
+import { GraphQLNonNull, GraphQLList, GraphQLScalarType, GraphQLEnumType, GraphQLDirective, Kind, GraphQLObjectType, getNamedType, getNullableType, GraphQLInterfaceType, GraphQLUnionType, GraphQLInputObjectType, DirectiveLocation, specifiedDirectives, isTypeExtensionNode, GraphQLError, isTypeDefinitionNode, parse as parse$3, Source, buildASTSchema, validateSchema } from 'graphql';
 import jen$1, { jen } from 'jennifer-js';
 import format from 'jennifer-js/format';
 import partition from 'just-partition';
@@ -338,14 +338,8 @@ function renderAstNode(astNode) {
 }
 function isBuiltInDirective(name) {
     // https://spec.graphql.org/draft/#sec-Type-System.Directives.Built-in-Directives
-    switch (name) {
-        case "deprecated":
-        case "skip":
-        case "include":
-        case "specifiedBy":
-            return true;
-    }
-    return false;
+    // Use the list from graphql, because new versions add directives (for example, @oneOf).
+    return specifiedDirectives.some((d) => d.name === name);
 }
 function truthify(arr) {
     return arr.filter(Boolean);
@@ -1611,6 +1605,9 @@ function setTraceToSchema(err, name, loc) {
     }
     return err;
 }
+function isMergableDefinitionNode(node) {
+    return isTypeDefinitionNode(node) || node.kind === Kind.DIRECTIVE_DEFINITION;
+}
 function namedNodesDict(nodes = []) {
     return Object.fromEntries(nodes.map((node) => [node.name.value, node]));
 }
@@ -1724,7 +1721,7 @@ function mergeFieldDefinitionNodes(name, a, b) {
                 console.warn(`WARNING: there is more than one declaration for ${name}.${f.name.value}${traceLine(f.loc)}${traceLine(prev.loc, "previously ")}\n`);
                 fields[f.name.value] = {
                     ...prev,
-                    directives: mergeDirectiveNodes(`${name}.${f.name.value}`, prev.directives, f.directives),
+                    directives: mergeDirectiveNodes(prev.directives, f.directives),
                 };
             }
             else {
@@ -1749,7 +1746,7 @@ function mergeInputValueDefinitionNodes(name, a, b) {
                 console.warn(`WARNING: there is more than one declaration for ${name}.${f.name.value}${traceLine(f.loc)}${traceLine(prev.loc, "previously ")}\n`);
                 fields[f.name.value] = {
                     ...prev,
-                    directives: mergeDirectiveNodes(`${name}.${f.name.value}`, prev.directives, f.directives),
+                    directives: mergeDirectiveNodes(prev.directives, f.directives),
                 };
             }
             else {
@@ -1768,18 +1765,19 @@ function mergeNamedNodes(a, b) {
     }
     return Object.values(nodes);
 }
-function mergeDirectiveNodes(name, a, b) {
-    const directives = namedNodesDict(a);
-    if (b) {
-        for (const d of b) {
-            if (d.name.value in directives &&
-                !isArgumentNodesEqual(directives[d.name.value].arguments, d.arguments)) {
-                throw setTraceToSchema(new GraphQLError(`Cannot merge duplicate directive with different arguments: ${name} @${d.name.value}`), `${name} @${d.name.value}`, d.loc);
-            }
-            directives[d.name.value] = d;
-        }
-    }
-    return Object.values(directives);
+function mergeDirectiveNodes(a, b) {
+    // Keep each occurrence, because a repeatable directive can occur more than
+    // once. Skip only an occurrence that is identical to one that is already
+    // applied. buildASTSchema rejects a non-repeatable directive that occurs
+    // more than once.
+    const directives = Array.from(a ?? []);
+    for (const d of b ?? []) {
+        if (!directives.some((prev) => prev.name.value === d.name.value &&
+            isArgumentNodesEqual(prev.arguments, d.arguments))) {
+            directives.push(d);
+        }
+    }
+    return directives;
 }
 function mergeScalarTypeDefinitionNodes(a, b) {
     if (a.name.value !== b.name.value) {
@@ -1787,8 +1785,10 @@ function mergeScalarTypeDefinitionNodes(a, b) {
     }
     return {
         kind: Kind.SCALAR_TYPE_DEFINITION,
+        loc: a.loc,
         name: a.name,
-        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        description: a.description || b.description,
+        directives: mergeDirectiveNodes(a.directives, b.directives),
     };
 }
 function mergeObjectTypeDefinitionNodes(a, b) {
@@ -1798,7 +1798,7 @@ function mergeObjectTypeDefinitionNodes(a, b) {
         name: a.name,
         description: a.description || b.description,
         interfaces: mergeNamedNodes(a.interfaces, b.interfaces),
-        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        directives: mergeDirectiveNodes(a.directives, b.directives),
         fields: mergeFieldDefinitionNodes(a.name.value, a.fields, b.fields),
     };
 }
@@ -1809,7 +1809,7 @@ function mergeInterfaceTypeDefinitionNodes(a, b) {
         name: a.name,
         description: a.description || b.description,
         interfaces: mergeNamedNodes(a.interfaces, b.interfaces),
-        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        directives: mergeDirectiveNodes(a.directives, b.directives),
         fields: mergeFieldDefinitionNodes(a.name.value, a.fields, b.fields),
     };
 }
@@ -1819,7 +1819,7 @@ function mergeUnionTypeDefinitionNodes(a, b) {
         loc: a.loc,
         name: a.name,
         description: a.description || b.description,
-        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        directives: mergeDirectiveNodes(a.directives, b.directives),
         types: mergeNamedNodes(a.types, b.types),
     };
 }
@@ -1828,7 +1828,7 @@ function mergeEnumTypeDefinitionNodes(a, b) {
     if (b) {
         for (const v of b.values || []) {
             if (v.name.value in values) {
-                throw setTraceToSchema(new GraphQLError(`Cannot merge duplicate enum value: ${v.name.value}.${v.name.value}`), `${v.name.value}.${v.name.value}`, v.loc);
+                throw setTraceToSchema(new GraphQLError(`Cannot merge duplicate enum value: ${a.name.value}.${v.name.value}`), `${a.name.value}.${v.name.value}`, v.loc);
             }
             values[v.name.value] = v;
         }
@@ -1838,7 +1838,7 @@ function mergeEnumTypeDefinitionNodes(a, b) {
         loc: a.loc,
         name: a.name,
         description: a.description || b.description,
-        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        directives: mergeDirectiveNodes(a.directives, b.directives),
         values: Object.values(values),
     };
 }
@@ -1848,26 +1848,74 @@ function mergeInputObjectTypeDefinitionNodes(a, b) {
         loc: a.loc,
         name: a.name,
         description: a.description || b.description,
-        directives: mergeDirectiveNodes(a.name.value, a.directives, b.directives),
+        directives: mergeDirectiveNodes(a.directives, b.directives),
         fields: mergeInputValueDefinitionNodes(a.name.value, a.fields, b.fields),
     };
 }
+const EXTENSION_DEFINITION_KINDS = {
+    [Kind.SCALAR_TYPE_EXTENSION]: Kind.SCALAR_TYPE_DEFINITION,
+    [Kind.OBJECT_TYPE_EXTENSION]: Kind.OBJECT_TYPE_DEFINITION,
+    [Kind.INTERFACE_TYPE_EXTENSION]: Kind.INTERFACE_TYPE_DEFINITION,
+    [Kind.UNION_TYPE_EXTENSION]: Kind.UNION_TYPE_DEFINITION,
+    [Kind.ENUM_TYPE_EXTENSION]: Kind.ENUM_TYPE_DEFINITION,
+    [Kind.INPUT_OBJECT_TYPE_EXTENSION]: Kind.INPUT_OBJECT_TYPE_DEFINITION,
+};
+function mergeTypeDefinitionNodes(a, b) {
+    switch (b.kind) {
+        case Kind.SCALAR_TYPE_DEFINITION:
+            return mergeScalarTypeDefinitionNodes(a, b);
+        case Kind.OBJECT_TYPE_DEFINITION:
+            return mergeObjectTypeDefinitionNodes(a, b);
+        case Kind.INTERFACE_TYPE_DEFINITION:
+            return mergeInterfaceTypeDefinitionNodes(a, b);
+        case Kind.UNION_TYPE_DEFINITION:
+            return mergeUnionTypeDefinitionNodes(a, b);
+        case Kind.ENUM_TYPE_DEFINITION:
+            return mergeEnumTypeDefinitionNodes(a, b);
+        case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+            return mergeInputObjectTypeDefinitionNodes(a, b);
+    }
+}
+function applyTypeExtensionNode(definitions, extension) {
+    const name = extension.name.value;
+    const definition = definitions[name];
+    if (!definition) {
+        throw setTraceToSchema(new GraphQLError(`Cannot extend type that is not defined: ${name}`), name, extension.loc);
+    }
+    const kind = EXTENSION_DEFINITION_KINDS[extension.kind];
+    if (definition.kind !== kind) {
+        throw setTraceToSchema(new GraphQLError(`Cannot extend ${definition.kind} with ${extension.kind}: ${name}`), name, extension.loc);
+    }
+    // An extension has the same shape as its definition, without a description.
+    const merged = mergeTypeDefinitionNodes(definition, {
+        ...extension,
+        kind,
+        directives: undefined,
+    });
+    // The directives of an extension are added to the directives of the type.
+    // buildASTSchema rejects a non-repeatable directive that occurs more than
+    // once.
+    definitions[name] = {
+        ...merged,
+        directives: [
+            ...(definition.directives ?? []),
+            ...(extension.directives ?? []),
+        ],
+    };
+}
 function mergeDocumentNodes(documentNodes) {
     const definitions = {};
+    const extensions = [];
     for (const documentNode of documentNodes) {
         for (const definition of documentNode.definitions) {
-            switch (definition.kind) {
-                case Kind.SCHEMA_DEFINITION:
-                case Kind.SCHEMA_EXTENSION:
-                case Kind.OPERATION_DEFINITION:
-                case Kind.FRAGMENT_DEFINITION:
-                case Kind.SCALAR_TYPE_EXTENSION:
-                case Kind.OBJECT_TYPE_EXTENSION:
-                case Kind.INTERFACE_TYPE_EXTENSION:
-                case Kind.UNION_TYPE_EXTENSION:
-                case Kind.ENUM_TYPE_EXTENSION:
-                case Kind.INPUT_OBJECT_TYPE_EXTENSION:
-                    throw new Error(`unexpected definition kind: ${definition.kind}`);
+            if (isTypeExtensionNode(definition)) {
+                // Apply extensions after all definitions are known, because an
+                // extension can occur before the definition that it extends.
+                extensions.push(definition);
+                continue;
+            }
+            if (!isMergableDefinitionNode(definition)) {
+                throw new Error(`unexpected definition kind: ${definition.kind}`);
             }
             const prevDefinition = definitions[definition.name.value];
             if (!prevDefinition) {
@@ -1885,30 +1933,12 @@ function mergeDocumentNodes(documentNodes) {
                 prevDefinition.description.value !== definition.description.value) {
                 console.warn(`WARNING: different descriptions for type ${prevDefinition.name.value}: ${JSON.stringify(prevDefinition.description.value)} and ${JSON.stringify(definition.description.value)}${traceLine(definition.description.loc)}${traceLine(prevDefinition.description.loc, "previously ")}\n`);
             }
-            switch (definition.kind) {
-                case Kind.SCALAR_TYPE_DEFINITION:
-                    definitions[definition.name.value] = mergeScalarTypeDefinitionNodes(prevDefinition, definition);
-                    break;
-                case Kind.OBJECT_TYPE_DEFINITION:
-                    definitions[definition.name.value] = mergeObjectTypeDefinitionNodes(prevDefinition, definition);
-                    break;
-                case Kind.INTERFACE_TYPE_DEFINITION:
-                    definitions[definition.name.value] =
-                        mergeInterfaceTypeDefinitionNodes(prevDefinition, definition);
-                    break;
-                case Kind.UNION_TYPE_DEFINITION:
-                    definitions[definition.name.value] = mergeUnionTypeDefinitionNodes(prevDefinition, definition);
-                    break;
-                case Kind.ENUM_TYPE_DEFINITION:
-                    definitions[definition.name.value] = mergeEnumTypeDefinitionNodes(prevDefinition, definition);
-                    break;
-                case Kind.INPUT_OBJECT_TYPE_DEFINITION:
-                    definitions[definition.name.value] =
-                        mergeInputObjectTypeDefinitionNodes(prevDefinition, definition);
-                    break;
-            }
+            definitions[definition.name.value] = mergeTypeDefinitionNodes(prevDefinition, definition);
         }
     }
+    for (const extension of extensions) {
+        applyTypeExtensionNode(definitions, extension);
+    }
     return {
         kind: Kind.DOCUMENT,
         loc: documentNodes[0].loc,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "graphql-jerky",
-	"version": "1.0.8",
+	"version": "1.0.9",
 	"description": "Jerky is a schema-first static graphql schema lightweight code generator.",
 	"type": "module",
 	"bin": "./build/bin/jerky.cjs",