graphql-jerky 1.0.8 → 1.0.10

package/README.md

@@ -31,9 +31,33 @@ By default, the working directory is searched recursively for `*.graphql` files.
 All of which are combined into a single schema and rendered to `schema_gen.ts`
 in the same directory.
 
+Jerky reads the schema files and the resolver files in the order of their
+paths. Thus, the output is the same on all platforms and file systems.
+
 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

@@ -277,6 +277,30 @@ class RequiredPackages {
     }
 }
 
+/**
+ * Glob options that make Windows paths work as patterns. On Windows, a
+ * backslash is a path separator and not an escape character.
+ */
+const globOptions = {
+    windowsPathsNoEscape: path.sep === "\\",
+};
+/**
+ * Converts native path separators to forward slashes.
+ *
+ * Glob patterns and module specifiers must use forward slashes, even on
+ * Windows.
+ */
+function toPosixPath(p) {
+    return path.sep === "\\" ? p.replaceAll("\\", "/") : p;
+}
+/**
+ * Compares paths by code unit. The result does not change with the locale
+ * or with the order in which the file system returns entries.
+ */
+function comparePaths(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+
 function renderSymbolReference(pkgs, ref, alias) {
     const ns = ref.module
         ? jen.jen.id(pkgs.addRequires(ref.module, ref.symbol, alias ?? ref.alias))
@@ -285,10 +309,10 @@ function renderSymbolReference(pkgs, ref, alias) {
 }
 
 function compareEntryKey([a], [b]) {
-    return a.localeCompare(b);
+    return a.localeCompare(b, "en");
 }
 function compareName({ name: a }, { name: b }) {
-    return a.localeCompare(b);
+    return a.localeCompare(b, "en");
 }
 const PRIMITIVE_TYPES = new Set(["ID", "Int", "Float", "String", "Boolean"]);
 function isPrimitiveType(type) {
@@ -307,8 +331,9 @@ function renderImports(base, imports, aliases, extMode = "omit") {
         if (mod.startsWith("file:///")) {
             mod = node_url.fileURLToPath(mod);
         }
-        if (mod.startsWith("/")) {
-            mod = path.relative(base, mod);
+        if (path.isAbsolute(mod)) {
+            // NOTE: module specifiers always use forward slashes, even on Windows.
+            mod = toPosixPath(path.relative(base, mod));
             if (!mod.startsWith(".")) {
                 mod = `./${mod}`;
             }
@@ -324,8 +349,8 @@ function renderImports(base, imports, aliases, extMode = "omit") {
         }
         return jen.import
             .obj(...Array.from(symbols)
-            .sort((a, b) => a.localeCompare(b) ||
-            importAlias(a).localeCompare(importAlias(b)))
+            .sort((a, b) => a.localeCompare(b, "en") ||
+            importAlias(a).localeCompare(importAlias(b), "en"))
             .map((symbol) => symbol in aliases
             ? jen.id(aliases[symbol]).as.id(symbol)
             : jen.id(symbol)))
@@ -340,14 +365,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);
@@ -1098,9 +1117,9 @@ class GeneratorContext {
         ];
     }
     renderFile(outfile, renderStatements) {
-        const base = outfile.startsWith("/") ? outfile : path.resolve(outfile);
+        const base = path.resolve(outfile);
         const statements = renderStatements.call(this);
-        const [localImports, externalImports] = partition(Object.entries(this._pkgs.requires), ([pkg]) => pkg.startsWith("/"));
+        const [localImports, externalImports] = partition(Object.entries(this._pkgs.requires), ([pkg]) => path.isAbsolute(pkg));
         return format(jen
             .statements(renderImports(path.dirname(base), externalImports, this._pkgs.aliases, this._extMode), renderImports(path.dirname(base), localImports, this._pkgs.aliases, this._extMode), ...statements)
             .toString());
@@ -1281,23 +1300,25 @@ async function parseResolverFile(path) {
 async function parseTypeResolvers(typeName, glob$1, ignore) {
     const shouldIgnore = createMatcher(ignore);
     const result = {};
-    for await (const entry of glob.globIterate(glob$1, { withFileTypes: true })) {
-        const fullpath = entry.fullpath();
-        if (!shouldIgnore(fullpath) &&
-            entry.isFile() &&
-            entry.name.endsWith(".ts")) {
-            for (const [name, reference] of Object.entries(await parseResolverFile(fullpath))) {
-                let realName = name;
-                if (realName === "default" &&
-                    typeof glob$1 === "string" &&
-                    glob$1.endsWith("/*.ts")) {
-                    realName = path.basename(fullpath, path.extname(fullpath));
-                }
-                if (realName in result) {
-                    console.warn(`WARNING: Duplicate resolver name: ${typeName ? `${typeName}.` : ""}${name} in ${fullpath} and ${result[name].module}`);
-                }
-                result[realName] = reference;
-            }
+    // NOTE: sort the files so that the result (and the warnings) do not change
+    // with the order in which the file system returns entries.
+    const fullpaths = (await glob.glob(glob$1, { ...globOptions, withFileTypes: true }))
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".ts"))
+        .map((entry) => toPosixPath(entry.fullpath()))
+        .filter((fullpath) => !shouldIgnore(fullpath))
+        .sort(comparePaths);
+    for (const fullpath of fullpaths) {
+        for (const [name, reference] of Object.entries(await parseResolverFile(fullpath))) {
+            let realName = name;
+            if (realName === "default" &&
+                typeof glob$1 === "string" &&
+                toPosixPath(glob$1).endsWith("/*.ts")) {
+                realName = path.basename(fullpath, path.extname(fullpath));
+            }
+            if (realName in result) {
+                console.warn(`WARNING: Duplicate resolver name: ${typeName ? `${typeName}.` : ""}${realName} in ${fullpath} and ${result[realName].module}`);
+            }
+            result[realName] = reference;
         }
     }
     return result;
@@ -1309,8 +1330,9 @@ async function parse$2(dirpath, ignore) {
     }
     const out = {};
     const shouldIgnore = createMatcher(ignore);
-    for await (const name of await fs.readdir(dirpath)) {
-        const file = path.join(dirpath, name);
+    const names = (await fs.readdir(dirpath)).sort(comparePaths);
+    for (const name of names) {
+        const file = path.posix.join(toPosixPath(dirpath), name);
         const entry = await fs.stat(file);
         if (entry.isDirectory()) {
             out[name] = await parseTypeResolvers(name, `${file}/*.ts`, shouldIgnore);
@@ -1613,11 +1635,14 @@ 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]));
 }
 function sortNamedNodes(nodes) {
-    return Array.from(nodes).sort(({ name: { value: a } }, { name: { value: b } }) => a.localeCompare(b));
+    return Array.from(nodes).sort(({ name: { value: a } }, { name: { value: b } }) => a.localeCompare(b, "en"));
 }
 function isIntValueNodeEqual(a, b) {
     return a.value === b.value;
@@ -1726,7 +1751,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 +1776,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 +1795,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 +1815,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 +1828,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 +1839,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 +1849,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 +1858,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 +1868,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 +1878,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 +1963,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,
@@ -1918,21 +1976,31 @@ function mergeDocumentNodes(documentNodes) {
     };
 }
 
-async function* findSchemaFiles(glob$1) {
-    for await (const path$1 of glob.globIterate(glob$1)) {
+async function collectSchemaFiles(glob$1, files) {
+    for (const path$1 of await glob.glob(glob$1, globOptions)) {
         const entry = await fs.stat(path$1);
         if (entry.isFile()) {
-            yield path$1;
+            files.add(toPosixPath(path$1));
         }
         else if (entry.isDirectory()) {
-            yield* findSchemaFiles(path.join(path$1, "**/*.graphql"));
+            await collectSchemaFiles(path.posix.join(toPosixPath(path$1), "**/*.graphql"), files);
         }
     }
 }
+/**
+ * Finds the schema files and sorts them by path. The order of the files sets
+ * the order of the merged definitions and fields, so it must not change with
+ * the file system or the platform.
+ */
+async function findSchemaFiles(glob) {
+    const files = new Set();
+    await collectSchemaFiles(glob, files);
+    return Array.from(files).sort(comparePaths);
+}
 async function parse(glob, ignore) {
     const shouldIgnore = createMatcher(ignore);
     const documentNodes = [];
-    for await (const entry of findSchemaFiles(glob)) {
+    for (const entry of await findSchemaFiles(glob)) {
         if (shouldIgnore(entry)) {
             continue;
         }

package/build/lib.mjs

@@ -1,13 +1,13 @@
-import path, { resolve, basename, extname, join } from 'node:path';
+import path, { resolve, basename, extname, posix } 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';
 import pascalCase from 'just-pascal-case';
 import fs from 'node:fs/promises';
 import ts, { getLineAndCharacterOfPosition } from 'typescript';
-import { globIterate } from 'glob';
+import { glob } from 'glob';
 import pm from 'picomatch';
 import zip from 'just-zip-it';
 
@@ -275,6 +275,30 @@ class RequiredPackages {
     }
 }
 
+/**
+ * Glob options that make Windows paths work as patterns. On Windows, a
+ * backslash is a path separator and not an escape character.
+ */
+const globOptions = {
+    windowsPathsNoEscape: path.sep === "\\",
+};
+/**
+ * Converts native path separators to forward slashes.
+ *
+ * Glob patterns and module specifiers must use forward slashes, even on
+ * Windows.
+ */
+function toPosixPath(p) {
+    return path.sep === "\\" ? p.replaceAll("\\", "/") : p;
+}
+/**
+ * Compares paths by code unit. The result does not change with the locale
+ * or with the order in which the file system returns entries.
+ */
+function comparePaths(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+
 function renderSymbolReference(pkgs, ref, alias) {
     const ns = ref.module
         ? jen.id(pkgs.addRequires(ref.module, ref.symbol, alias ?? ref.alias))
@@ -283,10 +307,10 @@ function renderSymbolReference(pkgs, ref, alias) {
 }
 
 function compareEntryKey([a], [b]) {
-    return a.localeCompare(b);
+    return a.localeCompare(b, "en");
 }
 function compareName({ name: a }, { name: b }) {
-    return a.localeCompare(b);
+    return a.localeCompare(b, "en");
 }
 const PRIMITIVE_TYPES = new Set(["ID", "Int", "Float", "String", "Boolean"]);
 function isPrimitiveType(type) {
@@ -305,8 +329,9 @@ function renderImports(base, imports, aliases, extMode = "omit") {
         if (mod.startsWith("file:///")) {
             mod = fileURLToPath(mod);
         }
-        if (mod.startsWith("/")) {
-            mod = path.relative(base, mod);
+        if (path.isAbsolute(mod)) {
+            // NOTE: module specifiers always use forward slashes, even on Windows.
+            mod = toPosixPath(path.relative(base, mod));
             if (!mod.startsWith(".")) {
                 mod = `./${mod}`;
             }
@@ -322,8 +347,8 @@ function renderImports(base, imports, aliases, extMode = "omit") {
         }
         return jen$1.import
             .obj(...Array.from(symbols)
-            .sort((a, b) => a.localeCompare(b) ||
-            importAlias(a).localeCompare(importAlias(b)))
+            .sort((a, b) => a.localeCompare(b, "en") ||
+            importAlias(a).localeCompare(importAlias(b), "en"))
             .map((symbol) => symbol in aliases
             ? jen$1.id(aliases[symbol]).as.id(symbol)
             : jen$1.id(symbol)))
@@ -338,14 +363,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);
@@ -1096,9 +1115,9 @@ class GeneratorContext {
         ];
     }
     renderFile(outfile, renderStatements) {
-        const base = outfile.startsWith("/") ? outfile : path.resolve(outfile);
+        const base = path.resolve(outfile);
         const statements = renderStatements.call(this);
-        const [localImports, externalImports] = partition(Object.entries(this._pkgs.requires), ([pkg]) => pkg.startsWith("/"));
+        const [localImports, externalImports] = partition(Object.entries(this._pkgs.requires), ([pkg]) => path.isAbsolute(pkg));
         return format(jen$1
             .statements(renderImports(path.dirname(base), externalImports, this._pkgs.aliases, this._extMode), renderImports(path.dirname(base), localImports, this._pkgs.aliases, this._extMode), ...statements)
             .toString());
@@ -1276,26 +1295,28 @@ async function parseResolverFile(path) {
         return [];
     })));
 }
-async function parseTypeResolvers(typeName, glob, ignore) {
+async function parseTypeResolvers(typeName, glob$1, ignore) {
     const shouldIgnore = createMatcher(ignore);
     const result = {};
-    for await (const entry of globIterate(glob, { withFileTypes: true })) {
-        const fullpath = entry.fullpath();
-        if (!shouldIgnore(fullpath) &&
-            entry.isFile() &&
-            entry.name.endsWith(".ts")) {
-            for (const [name, reference] of Object.entries(await parseResolverFile(fullpath))) {
-                let realName = name;
-                if (realName === "default" &&
-                    typeof glob === "string" &&
-                    glob.endsWith("/*.ts")) {
-                    realName = basename(fullpath, extname(fullpath));
-                }
-                if (realName in result) {
-                    console.warn(`WARNING: Duplicate resolver name: ${typeName ? `${typeName}.` : ""}${name} in ${fullpath} and ${result[name].module}`);
-                }
-                result[realName] = reference;
-            }
+    // NOTE: sort the files so that the result (and the warnings) do not change
+    // with the order in which the file system returns entries.
+    const fullpaths = (await glob(glob$1, { ...globOptions, withFileTypes: true }))
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".ts"))
+        .map((entry) => toPosixPath(entry.fullpath()))
+        .filter((fullpath) => !shouldIgnore(fullpath))
+        .sort(comparePaths);
+    for (const fullpath of fullpaths) {
+        for (const [name, reference] of Object.entries(await parseResolverFile(fullpath))) {
+            let realName = name;
+            if (realName === "default" &&
+                typeof glob$1 === "string" &&
+                toPosixPath(glob$1).endsWith("/*.ts")) {
+                realName = basename(fullpath, extname(fullpath));
+            }
+            if (realName in result) {
+                console.warn(`WARNING: Duplicate resolver name: ${typeName ? `${typeName}.` : ""}${realName} in ${fullpath} and ${result[realName].module}`);
+            }
+            result[realName] = reference;
         }
     }
     return result;
@@ -1307,8 +1328,9 @@ async function parse$2(dirpath, ignore) {
     }
     const out = {};
     const shouldIgnore = createMatcher(ignore);
-    for await (const name of await fs.readdir(dirpath)) {
-        const file = join(dirpath, name);
+    const names = (await fs.readdir(dirpath)).sort(comparePaths);
+    for (const name of names) {
+        const file = posix.join(toPosixPath(dirpath), name);
         const entry = await fs.stat(file);
         if (entry.isDirectory()) {
             out[name] = await parseTypeResolvers(name, `${file}/*.ts`, shouldIgnore);
@@ -1611,11 +1633,14 @@ 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]));
 }
 function sortNamedNodes(nodes) {
-    return Array.from(nodes).sort(({ name: { value: a } }, { name: { value: b } }) => a.localeCompare(b));
+    return Array.from(nodes).sort(({ name: { value: a } }, { name: { value: b } }) => a.localeCompare(b, "en"));
 }
 function isIntValueNodeEqual(a, b) {
     return a.value === b.value;
@@ -1724,7 +1749,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 +1774,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 +1793,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 +1813,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 +1826,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 +1837,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 +1847,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 +1856,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 +1866,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 +1876,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 +1961,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,
@@ -1916,21 +1974,31 @@ function mergeDocumentNodes(documentNodes) {
     };
 }
 
-async function* findSchemaFiles(glob) {
-    for await (const path of globIterate(glob)) {
+async function collectSchemaFiles(glob$1, files) {
+    for (const path of await glob(glob$1, globOptions)) {
         const entry = await fs.stat(path);
         if (entry.isFile()) {
-            yield path;
+            files.add(toPosixPath(path));
         }
         else if (entry.isDirectory()) {
-            yield* findSchemaFiles(join(path, "**/*.graphql"));
+            await collectSchemaFiles(posix.join(toPosixPath(path), "**/*.graphql"), files);
         }
     }
 }
+/**
+ * Finds the schema files and sorts them by path. The order of the files sets
+ * the order of the merged definitions and fields, so it must not change with
+ * the file system or the platform.
+ */
+async function findSchemaFiles(glob) {
+    const files = new Set();
+    await collectSchemaFiles(glob, files);
+    return Array.from(files).sort(comparePaths);
+}
 async function parse(glob, ignore) {
     const shouldIgnore = createMatcher(ignore);
     const documentNodes = [];
-    for await (const entry of findSchemaFiles(glob)) {
+    for (const entry of await findSchemaFiles(glob)) {
         if (shouldIgnore(entry)) {
             continue;
         }

package/package.json

@@ -1,9 +1,11 @@
 {
 	"name": "graphql-jerky",
-	"version": "1.0.8",
+	"version": "1.0.10",
 	"description": "Jerky is a schema-first static graphql schema lightweight code generator.",
 	"type": "module",
-	"bin": "./build/bin/jerky.cjs",
+	"bin": {
+		"graphql-jerky": "build/bin/jerky.cjs"
+	},
 	"types": "./build/lib.d.ts",
 	"module": "./build/lib.mjs",
 	"main": "./build/lib.cjs",