graphql-jerky 1.0.1 → 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) {
@@ -419,7 +420,7 @@ 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, noresolver) {
@@ -501,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
@@ -880,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 }]) => {
@@ -897,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") {
@@ -916,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`);
@@ -925,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;
@@ -1517,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) {
@@ -417,7 +418,7 @@ 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, noresolver) {
@@ -499,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
@@ -878,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 }]) => {
@@ -895,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") {
@@ -914,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`);
@@ -923,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;
@@ -1515,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.1",
+    "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"