graphql-jerky 1.0.0 → 1.0.2

package/build/bin/jerky.mjs

@@ -12,6 +12,7 @@ import 'just-pascal-case';
 import 'url';
 import 'typescript';
 import 'glob';
+import 'picomatch';
 import 'just-zip-it';
 
 program

package/build/lib.cjs

@@ -10,6 +10,7 @@ var url = require('url');
 var fs = require('fs/promises');
 var ts = require('typescript');
 var glob = require('glob');
+var pm = require('picomatch');
 var zip = require('just-zip-it');
 
 async function parseSource(filepath) {
@@ -363,38 +364,41 @@ class GeneratorContext {
     _renderArgumentNodes(nodes) {
         return jen.obj(...Array.from(nodes ?? [], (arg) => jen.prop(arg.name.value, this._renderValueNode(arg.value))));
     }
-    _renderFieldObject(type, f, inputFieldDirectives) {
-        let resolver = this._resolversInfo[type.name]?.[f.name];
-        if (type instanceof graphql.GraphQLObjectType && !resolver) {
-            // try to find resolver in interface in the declaration order
-            for (const iface of type.getInterfaces()) {
-                if ((resolver = this._resolversInfo[iface.name]?.[f.name])) {
-                    break;
+    _renderFieldObject(type, f, inputFieldDirectives, noresolver) {
+        let resolveFn;
+        if (!noresolver) {
+            let resolver = this._resolversInfo[type.name]?.[f.name];
+            if (type instanceof graphql.GraphQLObjectType && !resolver) {
+                // try to find resolver in interface in the declaration order
+                for (const iface of type.getInterfaces()) {
+                    if ((resolver = this._resolversInfo[iface.name]?.[f.name])) {
+                        break;
+                    }
                 }
             }
-        }
-        let resolveFn = resolver && renderSymbolReference(this._pkgs, resolver);
-        if (f.astNode?.directives?.length) {
-            // apply directives in reverse order
-            for (const directive of Array.from(f.astNode.directives).reverse()) {
-                const ref = this._fieldDirectivesInfo[directive.name.value];
-                if (!ref) {
-                    continue;
-                }
-                if (!resolveFn) {
-                    resolveFn = jen.arrow(jen.id("source").op(":").any).id("source").dot(f.name);
+            resolveFn = resolver && renderSymbolReference(this._pkgs, resolver);
+            if (f.astNode?.directives?.length) {
+                // apply directives in reverse order
+                for (const directive of Array.from(f.astNode.directives).reverse()) {
+                    const ref = this._fieldDirectivesInfo[directive.name.value];
+                    if (!ref) {
+                        continue;
+                    }
+                    if (!resolveFn) {
+                        resolveFn = jen.arrow(jen.id("source").op(":").any).id("source").dot(f.name);
+                    }
+                    resolveFn = renderSymbolReference(this._pkgs, ref, `apply${pascalCase(directive.name.value)}FieldDirective`).call(resolveFn, ...(directive.arguments?.length ? [this._renderArgumentNodes(directive.arguments)] : []));
                 }
-                resolveFn = renderSymbolReference(this._pkgs, ref, `apply${pascalCase(directive.name.value)}FieldDirective`).call(resolveFn, ...(directive.arguments?.length ? [this._renderArgumentNodes(directive.arguments)] : []));
             }
-        }
-        if (resolveFn) {
-            // args probably don't need to be transformed if there's no resolver
-            const argsWithDirectives = truthify(f.args?.map((arg) => this._findInputDirectiveInfoFromArgOrField(arg, inputFieldDirectives)) ?? []);
-            if (argsWithDirectives.length) {
-                resolveFn = jen.parens(jen.params(jen.prop("next", this._gql("GraphQLFieldResolver").types(jen.any, jen.any))).op(":")
-                    .add(this._gql("GraphQLFieldResolver"))
-                    .types(jen.any, jen.any, jen.id(type.name).dot(pascalCase(f.name + "_args")))
-                    .op("=>").arrow(jen.id("source"), jen.id("args"), jen.id("context"), jen.id("info")).id("next").call(jen.id("source"), this._renderInputFieldsWithDirectives(jen.id("args"), argsWithDirectives, argsWithDirectives.length < f.args.length), jen.id("context"), jen.id("info"))).call(resolveFn);
+            if (resolveFn) {
+                // args probably don't need to be transformed if there's no resolver
+                const argsWithDirectives = truthify(f.args?.map((arg) => this._findInputDirectiveInfoFromArgOrField(arg, inputFieldDirectives)) ?? []);
+                if (argsWithDirectives.length) {
+                    resolveFn = jen.parens(jen.params(jen.prop("next", this._gql("GraphQLFieldResolver").types(jen.any, jen.any))).op(":")
+                        .add(this._gql("GraphQLFieldResolver"))
+                        .types(jen.any, jen.any, jen.id(type.name).dot(pascalCase(f.name + "_args")))
+                        .op("=>").arrow(jen.id("source"), jen.id("args"), jen.id("context"), jen.id("info")).id("next").call(jen.id("source"), this._renderInputFieldsWithDirectives(jen.id("args"), argsWithDirectives, argsWithDirectives.length < f.args.length), jen.id("context"), jen.id("info"))).call(resolveFn);
+                }
             }
         }
         // NOTE: The way subscribers work in the graphql-js is by calling `subscribe` on the top level fields, and then
@@ -416,13 +420,13 @@ class GeneratorContext {
             // NOTE: Resolver functions on interface definitions are not used by the default graphql-js
             //       executor implementation, but nonetheless accessible by a potential alternate implementation.
             resolveFn && jen.prop("resolve", jen.parens(resolveFn).as.any),
-            subscriber && jen.prop("subscribe", renderSymbolReference(this._pkgs, subscriber)),
+            subscriber && jen.prop("subscribe", jen.parens(renderSymbolReference(this._pkgs, subscriber)).as.any),
         ]));
     }
-    _renderFieldsThunk(type, inputFieldDirectives) {
+    _renderFieldsThunk(type, inputFieldDirectives, noresolver) {
         return jen.arrow().parens(jen.obj(...Object.values(type.getFields())
             .sort(compareName)
-            .map((field) => jen.prop(field.name, this._renderFieldObject(type, field, inputFieldDirectives)))));
+            .map((field) => jen.prop(field.name, this._renderFieldObject(type, field, inputFieldDirectives, noresolver)))));
     }
     _renderOptionalGraphQLTypeType(type) {
         if (type instanceof graphql.GraphQLNonNull) {
@@ -498,7 +502,7 @@ class GeneratorContext {
     }
     _renderGraphQLObjectTypeDefinition(type, { inputFieldDirectives }) {
         const typeInterfaces = type.getInterfaces();
-        return jen.new.add(this._gql("GraphQLObjectType")).call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives)), ...truthify([
+        return jen.new.add(this._gql("GraphQLObjectType")).call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives, type.name === "Subscription")), ...truthify([
             type.description && jen.prop("description", jen.lit(type.description)),
             typeInterfaces.length && jen.prop("interfaces", jen.arrow().arr(
             // do not sort interfaces, the declaration order may be important
@@ -623,7 +627,7 @@ class GeneratorContext {
         }));
     }
     _renderGraphQLInputObjectTypeDefinition(type, { inputFieldDirectives }) {
-        return jen.new.add(this._gql("GraphQLInputObjectType")).call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives)), ...truthify([
+        return jen.new.add(this._gql("GraphQLInputObjectType")).call(jen.obj(jen.prop("name", jen.lit(type.name)), jen.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives, true)), ...truthify([
             type.description && jen.prop("description", jen.lit(type.description)),
         ])));
     }
@@ -877,6 +881,41 @@ function generate(schema, outfile, options = {}) {
     return createGenerator(schema, options).generate(outfile);
 }
 
+function createMatcher(pattern) {
+    if (!pattern) {
+        return () => false;
+    }
+    if (typeof pattern === "function") {
+        return pattern;
+    }
+    if (pattern instanceof RegExp) {
+        return (s) => pattern.test(s);
+    }
+    if (typeof pattern === "string") {
+        return pm(pattern);
+    }
+    let matchers = [];
+    let globs = [];
+    for (const p of Array.isArray(pattern) ? pattern : [pattern]) {
+        if (typeof p === "string") {
+            globs.push(p);
+        }
+        else if (typeof p === "function") {
+            matchers.push(p);
+        }
+        else if (p instanceof RegExp) {
+            matchers.push(RegExp.prototype.test.bind(p));
+        }
+        else {
+            throw new TypeError(`Invalid pattern: ${p}`);
+        }
+    }
+    if (globs.length) {
+        matchers.push(pm(globs));
+    }
+    return (s) => matchers.some((m) => m(s));
+}
+
 async function parseResolverFile(path) {
     return Object.fromEntries(Object.entries((await parseModule(path)).exports)
         .flatMap(([name, { declaration }]) => {
@@ -894,11 +933,12 @@ async function parseResolverFile(path) {
         return [];
     }));
 }
-async function parseTypeResolvers(typeName, glob$1) {
+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 (entry.isFile() && entry.name.endsWith(".ts")) {
+        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") {
@@ -913,7 +953,7 @@ async function parseTypeResolvers(typeName, glob$1) {
     }
     return result;
 }
-async function parse$2(dirpath) {
+async function parse$2(dirpath, ignore) {
     const dir = await fs.stat(dirpath);
     if (!dir.isDirectory()) {
         throw new Error(`Expected ${dirpath} to be a directory`);
@@ -922,14 +962,15 @@ async function parse$2(dirpath) {
         dirpath += "/";
     }
     const out = {};
+    const shouldIgnore = createMatcher(ignore);
     for await (const name of await fs.readdir(dirpath)) {
         const file = path.join(dirpath, name);
         const entry = await fs.stat(file);
         if (entry.isDirectory()) {
-            out[name] = await parseTypeResolvers(name, file + "/*.ts");
+            out[name] = await parseTypeResolvers(name, file + "/*.ts", shouldIgnore);
         }
         else if (entry.isFile() && name.endsWith(".ts")) {
-            out[name.slice(0, -3)] = await parseTypeResolvers(name.slice(0, -3), file);
+            out[name.slice(0, -3)] = await parseTypeResolvers(name.slice(0, -3), file, shouldIgnore);
         }
     }
     return out;
@@ -1514,9 +1555,13 @@ async function* findSchemaFiles(glob$1) {
         }
     }
 }
-async function parse(glob) {
+async function parse(glob, ignore) {
+    const shouldIgnore = createMatcher(ignore);
     const documentNodes = [];
     for await (const entry of findSchemaFiles(glob)) {
+        if (shouldIgnore(entry)) {
+            continue;
+        }
         documentNodes.push(graphql.parse(new graphql.Source(await fs.readFile(entry, "utf-8"), entry)));
     }
     if (!documentNodes.length) {

package/build/lib.d.ts

@@ -1,6 +1,8 @@
 import ts from 'typescript';
 import { GraphQLSchema } from 'graphql';
 
+type MatchPattern = string | RegExp | ((s: string) => boolean) | Array<string | RegExp | ((s: string) => boolean)>;
+
 interface SymbolReference {
     module?: string;
     symbol: string;
@@ -8,8 +10,8 @@ interface SymbolReference {
     property?: string;
 }
 
-declare function parseTypeResolvers(typeName: string, glob: string | string[]): Promise<Record<string, SymbolReference>>;
-declare function parse$2(dirpath: string): Promise<Record<string, Record<string, SymbolReference>>>;
+declare function parseTypeResolvers(typeName: string, glob: string | string[], ignore?: MatchPattern): Promise<Record<string, SymbolReference>>;
+declare function parse$2(dirpath: string, ignore?: MatchPattern): Promise<Record<string, Record<string, SymbolReference>>>;
 
 type FunctionDeclaration = ts.MethodDeclaration | ts.FunctionExpression | ts.ArrowFunction;
 interface ScalarFnsInfo {
@@ -46,6 +48,6 @@ declare function generateSchema(schema: GraphQLSchema, outfile: string, options?
 declare function generateTypes(schema: GraphQLSchema, outfile: string, options?: GenerateOptions): string;
 declare function generate(schema: GraphQLSchema, outfile: string, options?: GenerateOptions): string;
 
-declare function parse(glob: string | string[]): Promise<GraphQLSchema>;
+declare function parse(glob: string | string[], ignore?: MatchPattern): Promise<GraphQLSchema>;
 
 export { createGenerator, generate, generateSchema, generateTypes, parse$2 as parseResolvers, parse$1 as parseScalars, parse as parseSchema, parseTypeResolvers };

package/build/lib.mjs

@@ -8,6 +8,7 @@ import { pathToFileURL, fileURLToPath } from 'url';
 import fs from 'fs/promises';
 import ts, { getLineAndCharacterOfPosition } from 'typescript';
 import { globIterate } from 'glob';
+import pm from 'picomatch';
 import zip from 'just-zip-it';
 
 async function parseSource(filepath) {
@@ -361,38 +362,41 @@ class GeneratorContext {
     _renderArgumentNodes(nodes) {
         return jen$1.obj(...Array.from(nodes ?? [], (arg) => jen$1.prop(arg.name.value, this._renderValueNode(arg.value))));
     }
-    _renderFieldObject(type, f, inputFieldDirectives) {
-        let resolver = this._resolversInfo[type.name]?.[f.name];
-        if (type instanceof GraphQLObjectType && !resolver) {
-            // try to find resolver in interface in the declaration order
-            for (const iface of type.getInterfaces()) {
-                if ((resolver = this._resolversInfo[iface.name]?.[f.name])) {
-                    break;
+    _renderFieldObject(type, f, inputFieldDirectives, noresolver) {
+        let resolveFn;
+        if (!noresolver) {
+            let resolver = this._resolversInfo[type.name]?.[f.name];
+            if (type instanceof GraphQLObjectType && !resolver) {
+                // try to find resolver in interface in the declaration order
+                for (const iface of type.getInterfaces()) {
+                    if ((resolver = this._resolversInfo[iface.name]?.[f.name])) {
+                        break;
+                    }
                 }
             }
-        }
-        let resolveFn = resolver && renderSymbolReference(this._pkgs, resolver);
-        if (f.astNode?.directives?.length) {
-            // apply directives in reverse order
-            for (const directive of Array.from(f.astNode.directives).reverse()) {
-                const ref = this._fieldDirectivesInfo[directive.name.value];
-                if (!ref) {
-                    continue;
-                }
-                if (!resolveFn) {
-                    resolveFn = jen$1.arrow(jen$1.id("source").op(":").any).id("source").dot(f.name);
+            resolveFn = resolver && renderSymbolReference(this._pkgs, resolver);
+            if (f.astNode?.directives?.length) {
+                // apply directives in reverse order
+                for (const directive of Array.from(f.astNode.directives).reverse()) {
+                    const ref = this._fieldDirectivesInfo[directive.name.value];
+                    if (!ref) {
+                        continue;
+                    }
+                    if (!resolveFn) {
+                        resolveFn = jen$1.arrow(jen$1.id("source").op(":").any).id("source").dot(f.name);
+                    }
+                    resolveFn = renderSymbolReference(this._pkgs, ref, `apply${pascalCase(directive.name.value)}FieldDirective`).call(resolveFn, ...(directive.arguments?.length ? [this._renderArgumentNodes(directive.arguments)] : []));
                 }
-                resolveFn = renderSymbolReference(this._pkgs, ref, `apply${pascalCase(directive.name.value)}FieldDirective`).call(resolveFn, ...(directive.arguments?.length ? [this._renderArgumentNodes(directive.arguments)] : []));
             }
-        }
-        if (resolveFn) {
-            // args probably don't need to be transformed if there's no resolver
-            const argsWithDirectives = truthify(f.args?.map((arg) => this._findInputDirectiveInfoFromArgOrField(arg, inputFieldDirectives)) ?? []);
-            if (argsWithDirectives.length) {
-                resolveFn = jen$1.parens(jen$1.params(jen$1.prop("next", this._gql("GraphQLFieldResolver").types(jen$1.any, jen$1.any))).op(":")
-                    .add(this._gql("GraphQLFieldResolver"))
-                    .types(jen$1.any, jen$1.any, jen$1.id(type.name).dot(pascalCase(f.name + "_args")))
-                    .op("=>").arrow(jen$1.id("source"), jen$1.id("args"), jen$1.id("context"), jen$1.id("info")).id("next").call(jen$1.id("source"), this._renderInputFieldsWithDirectives(jen$1.id("args"), argsWithDirectives, argsWithDirectives.length < f.args.length), jen$1.id("context"), jen$1.id("info"))).call(resolveFn);
+            if (resolveFn) {
+                // args probably don't need to be transformed if there's no resolver
+                const argsWithDirectives = truthify(f.args?.map((arg) => this._findInputDirectiveInfoFromArgOrField(arg, inputFieldDirectives)) ?? []);
+                if (argsWithDirectives.length) {
+                    resolveFn = jen$1.parens(jen$1.params(jen$1.prop("next", this._gql("GraphQLFieldResolver").types(jen$1.any, jen$1.any))).op(":")
+                        .add(this._gql("GraphQLFieldResolver"))
+                        .types(jen$1.any, jen$1.any, jen$1.id(type.name).dot(pascalCase(f.name + "_args")))
+                        .op("=>").arrow(jen$1.id("source"), jen$1.id("args"), jen$1.id("context"), jen$1.id("info")).id("next").call(jen$1.id("source"), this._renderInputFieldsWithDirectives(jen$1.id("args"), argsWithDirectives, argsWithDirectives.length < f.args.length), jen$1.id("context"), jen$1.id("info"))).call(resolveFn);
+                }
             }
         }
         // NOTE: The way subscribers work in the graphql-js is by calling `subscribe` on the top level fields, and then
@@ -414,13 +418,13 @@ class GeneratorContext {
             // NOTE: Resolver functions on interface definitions are not used by the default graphql-js
             //       executor implementation, but nonetheless accessible by a potential alternate implementation.
             resolveFn && jen$1.prop("resolve", jen$1.parens(resolveFn).as.any),
-            subscriber && jen$1.prop("subscribe", renderSymbolReference(this._pkgs, subscriber)),
+            subscriber && jen$1.prop("subscribe", jen$1.parens(renderSymbolReference(this._pkgs, subscriber)).as.any),
         ]));
     }
-    _renderFieldsThunk(type, inputFieldDirectives) {
+    _renderFieldsThunk(type, inputFieldDirectives, noresolver) {
         return jen$1.arrow().parens(jen$1.obj(...Object.values(type.getFields())
             .sort(compareName)
-            .map((field) => jen$1.prop(field.name, this._renderFieldObject(type, field, inputFieldDirectives)))));
+            .map((field) => jen$1.prop(field.name, this._renderFieldObject(type, field, inputFieldDirectives, noresolver)))));
     }
     _renderOptionalGraphQLTypeType(type) {
         if (type instanceof GraphQLNonNull) {
@@ -496,7 +500,7 @@ class GeneratorContext {
     }
     _renderGraphQLObjectTypeDefinition(type, { inputFieldDirectives }) {
         const typeInterfaces = type.getInterfaces();
-        return jen$1.new.add(this._gql("GraphQLObjectType")).call(jen$1.obj(jen$1.prop("name", jen$1.lit(type.name)), jen$1.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives)), ...truthify([
+        return jen$1.new.add(this._gql("GraphQLObjectType")).call(jen$1.obj(jen$1.prop("name", jen$1.lit(type.name)), jen$1.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives, type.name === "Subscription")), ...truthify([
             type.description && jen$1.prop("description", jen$1.lit(type.description)),
             typeInterfaces.length && jen$1.prop("interfaces", jen$1.arrow().arr(
             // do not sort interfaces, the declaration order may be important
@@ -621,7 +625,7 @@ class GeneratorContext {
         }));
     }
     _renderGraphQLInputObjectTypeDefinition(type, { inputFieldDirectives }) {
-        return jen$1.new.add(this._gql("GraphQLInputObjectType")).call(jen$1.obj(jen$1.prop("name", jen$1.lit(type.name)), jen$1.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives)), ...truthify([
+        return jen$1.new.add(this._gql("GraphQLInputObjectType")).call(jen$1.obj(jen$1.prop("name", jen$1.lit(type.name)), jen$1.prop("fields", this._renderFieldsThunk(type, inputFieldDirectives, true)), ...truthify([
             type.description && jen$1.prop("description", jen$1.lit(type.description)),
         ])));
     }
@@ -875,6 +879,41 @@ function generate(schema, outfile, options = {}) {
     return createGenerator(schema, options).generate(outfile);
 }
 
+function createMatcher(pattern) {
+    if (!pattern) {
+        return () => false;
+    }
+    if (typeof pattern === "function") {
+        return pattern;
+    }
+    if (pattern instanceof RegExp) {
+        return (s) => pattern.test(s);
+    }
+    if (typeof pattern === "string") {
+        return pm(pattern);
+    }
+    let matchers = [];
+    let globs = [];
+    for (const p of Array.isArray(pattern) ? pattern : [pattern]) {
+        if (typeof p === "string") {
+            globs.push(p);
+        }
+        else if (typeof p === "function") {
+            matchers.push(p);
+        }
+        else if (p instanceof RegExp) {
+            matchers.push(RegExp.prototype.test.bind(p));
+        }
+        else {
+            throw new TypeError(`Invalid pattern: ${p}`);
+        }
+    }
+    if (globs.length) {
+        matchers.push(pm(globs));
+    }
+    return (s) => matchers.some((m) => m(s));
+}
+
 async function parseResolverFile(path) {
     return Object.fromEntries(Object.entries((await parseModule(path)).exports)
         .flatMap(([name, { declaration }]) => {
@@ -892,11 +931,12 @@ async function parseResolverFile(path) {
         return [];
     }));
 }
-async function parseTypeResolvers(typeName, glob) {
+async function parseTypeResolvers(typeName, glob, ignore) {
+    const shouldIgnore = createMatcher(ignore);
     const result = {};
     for await (const entry of globIterate(glob, { withFileTypes: true })) {
         const fullpath = entry.fullpath();
-        if (entry.isFile() && entry.name.endsWith(".ts")) {
+        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") {
@@ -911,7 +951,7 @@ async function parseTypeResolvers(typeName, glob) {
     }
     return result;
 }
-async function parse$2(dirpath) {
+async function parse$2(dirpath, ignore) {
     const dir = await fs.stat(dirpath);
     if (!dir.isDirectory()) {
         throw new Error(`Expected ${dirpath} to be a directory`);
@@ -920,14 +960,15 @@ async function parse$2(dirpath) {
         dirpath += "/";
     }
     const out = {};
+    const shouldIgnore = createMatcher(ignore);
     for await (const name of await fs.readdir(dirpath)) {
         const file = join(dirpath, name);
         const entry = await fs.stat(file);
         if (entry.isDirectory()) {
-            out[name] = await parseTypeResolvers(name, file + "/*.ts");
+            out[name] = await parseTypeResolvers(name, file + "/*.ts", shouldIgnore);
         }
         else if (entry.isFile() && name.endsWith(".ts")) {
-            out[name.slice(0, -3)] = await parseTypeResolvers(name.slice(0, -3), file);
+            out[name.slice(0, -3)] = await parseTypeResolvers(name.slice(0, -3), file, shouldIgnore);
         }
     }
     return out;
@@ -1512,9 +1553,13 @@ async function* findSchemaFiles(glob) {
         }
     }
 }
-async function parse(glob) {
+async function parse(glob, ignore) {
+    const shouldIgnore = createMatcher(ignore);
     const documentNodes = [];
     for await (const entry of findSchemaFiles(glob)) {
+        if (shouldIgnore(entry)) {
+            continue;
+        }
         documentNodes.push(parse$3(new Source(await fs.readFile(entry, "utf-8"), entry)));
     }
     if (!documentNodes.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "graphql-jerky",
-    "version": "1.0.0",
+    "version": "1.0.2",
     "description": "Jerky is a schema-first static graphql schema lightweight code generator.",
     "type": "module",
     "bin": "./build/bin/jerky.cjs",
@@ -19,11 +19,13 @@
         "just-partition": "^2.2.0",
         "just-pascal-case": "^3.2.0",
         "just-zip-it": "^3.2.0",
+        "picomatch": "^2.3.1",
         "typescript": "^5.1.3"
     },
     "devDependencies": {
         "@rollup/plugin-typescript": "^11.1.1",
         "@types/node": "^20.3.1",
+        "@types/picomatch": "^2.3.0",
         "rollup": "^3.25.1",
         "rollup-plugin-dts": "^5.3.0",
         "tslib": "^2.5.3"