graphql-jerky 1.0.1 → 1.0.3

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) {
@@ -38,23 +39,26 @@ async function findExports(source, resolveModuleFn = resolveModule) {
         if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) {
             if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
                 if (node.modifiers.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword)) {
-                    exports.default = { declaration: node, source, name: "default" };
+                    (exports.default || (exports.default = [])).push({ declaration: node, source, name: "default" });
                 }
                 else if (node.name) {
-                    exports[node.name.getText(source)] = { declaration: node, source, name: node.name.getText(source) };
+                    const name = node.name.getText(source);
+                    (exports[name] || (exports[name] = [])).push({ declaration: node, source, name: name });
                 }
             }
         }
         else if (ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node)) {
             if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
-                exports[node.name.getText(source)] = { declaration: node, source, name: node.name.getText(source) };
+                const name = node.name.getText(source);
+                (exports[name] || (exports[name] = [])).push({ declaration: node, source, name: name });
             }
         }
         else if (ts.isVariableStatement(node)) {
             if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
                 for (const decl of node.declarationList.declarations) {
                     if (decl.name) {
-                        exports[decl.name.getText(source)] = { declaration: decl, source, name: decl.name.getText(source) };
+                        const name = decl.name.getText(source);
+                        (exports[name] || (exports[name] = [])).push({ declaration: decl, source, name: name });
                     }
                 }
             }
@@ -72,7 +76,7 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                         if (!(name in moduleExports)) {
                             throw new Error(`Exported name ${name} not found in ${JSON.stringify(specifier)}`);
                         }
-                        exports[name] = moduleExports[name];
+                        (exports[name] || (exports[name] = [])).push(...moduleExports[name]);
                     }
                 }
                 else {
@@ -81,7 +85,6 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                             name: element.name.text,
                             property: element.propertyName?.text,
                         });
-                        // exports[element.name.getText(source)] = { declaration: element, source };
                     }
                 }
             }
@@ -97,57 +100,63 @@ async function findExports(source, resolveModuleFn = resolveModule) {
             if (ts.isVariableStatement(statement)) {
                 for (const decl of statement.declarationList.declarations) {
                     if (ts.isIdentifier(decl.name) && decl.name.getText(source) in names) {
-                        exports[names[decl.name.getText(source)]] = {
+                        const name = names[decl.name.getText(source)];
+                        (exports[name] || (exports[name] = [])).push({
                             declaration: decl,
                             source,
                             name: names[decl.name.getText(source)],
-                        };
+                        });
                     }
                 }
             }
             if (ts.isFunctionDeclaration(statement)) {
                 if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
-                    exports[names[statement.name.getText(source)]] = {
+                    const name = names[statement.name.getText(source)];
+                    (exports[name] || (exports[name] = [])).push({
                         declaration: statement,
                         source,
                         name: names[statement.name.getText(source)],
-                    };
+                    });
                 }
             }
             if (ts.isClassDeclaration(statement)) {
                 if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
-                    exports[names[statement.name.getText(source)]] = {
+                    const name = names[statement.name.getText(source)];
+                    (exports[name] || (exports[name] = [])).push({
                         declaration: statement,
                         source,
                         name: names[statement.name.getText(source)],
-                    };
+                    });
                 }
             }
             if (ts.isTypeAliasDeclaration(statement)) {
                 if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
-                    exports[names[statement.name.getText(source)]] = {
+                    const name = names[statement.name.getText(source)];
+                    (exports[name] || (exports[name] = [])).push({
                         declaration: statement,
                         source,
                         name: names[statement.name.getText(source)],
-                    };
+                    });
                 }
             }
             if (ts.isInterfaceDeclaration(statement)) {
                 if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
-                    exports[names[statement.name.getText(source)]] = {
+                    const name = names[statement.name.getText(source)];
+                    (exports[name] || (exports[name] = [])).push({
                         declaration: statement,
                         source,
                         name: names[statement.name.getText(source)],
-                    };
+                    });
                 }
             }
             if (ts.isEnumDeclaration(statement)) {
                 if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
-                    exports[names[statement.name.getText(source)]] = {
+                    const name = names[statement.name.getText(source)];
+                    (exports[name] || (exports[name] = [])).push({
                         declaration: statement,
                         source,
                         name: names[statement.name.getText(source)],
-                    };
+                    });
                 }
             }
             if (ts.isImportDeclaration(statement)) {
@@ -167,11 +176,12 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                             if (!importExports[element.name.getText(source)]) {
                                 throw new Error(`Exported name ${element.name.getText(source)} not found in ${JSON.stringify(statement.moduleSpecifier.getText(source))}`);
                             }
-                            exports[names[element.propertyName.getText(source)]] = {
+                            const name = names[element.propertyName.getText(source)];
+                            (exports[name] || (exports[name] = [])).push({
                                 declaration: element,
                                 source,
                                 name: names[element.propertyName.getText(source)],
-                            };
+                            });
                         }
                     }
                 }
@@ -238,16 +248,9 @@ function compareEntryKey([a], [b]) {
 function compareName({ name: a }, { name: b }) {
     return a.localeCompare(b);
 }
+const PRIMITIVE_TYPES = new Set(["ID", "Int", "Float", "String", "Boolean"]);
 function isPrimitiveType(type) {
-    switch (type.name) {
-        case "ID":
-        case "Int":
-        case "Float":
-        case "String":
-        case "Boolean":
-            return true;
-    }
-    return false;
+    return PRIMITIVE_TYPES.has(type.name);
 }
 function importAlias(line) {
     const pos = line.indexOf(" as ");
@@ -419,7 +422,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 +504,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
@@ -741,6 +744,20 @@ class GeneratorContext {
                     .map((directive) => [directive.name, this._renderGraphQLDirectiveDefinition(directive)])
                     .sort(compareEntryKey),
             ].map(([, expr]) => expr),
+            ...Array.from(PRIMITIVE_TYPES)
+                .flatMap((type) => {
+                const info = this._scalarsInfo[type];
+                if (!info) {
+                    return [];
+                }
+                return [
+                    jen.statements(...[
+                        info.serializeFunc && this._gql("GraphQL" + type).dot("serialize").op("=").parens(renderSymbolReference(this._pkgs, info.serializeFunc).as.any),
+                        info.parseValueFunc && this._gql("GraphQL" + type).dot("parseValue").op("=").parens(renderSymbolReference(this._pkgs, info.parseValueFunc).as.any),
+                        info.parseLiteralFunc && this._gql("GraphQL" + type).dot("parseLiteral").op("=").parens(renderSymbolReference(this._pkgs, info.parseLiteralFunc).as.any),
+                    ].filter(Boolean))
+                ];
+            }),
             // render schema
             jen.const.id("schema").op("=").new.add(this._gql("GraphQLSchema")).call(jen.obj(...(schema.getQueryType()
                 ? [jen.prop("query", this._renderGraphQLTypeIdentifier(schema.getQueryType()))]
@@ -880,9 +897,44 @@ 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 }]) => {
+        .flatMap(([name, decls]) => decls.flatMap(({ declaration }) => {
         if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
             if (ts.isFunctionExpression(declaration.initializer)) {
                 return [[name, { module: path, symbol: name }]];
@@ -895,13 +947,14 @@ async function parseResolverFile(path) {
             return [[name, { module: path, symbol: name }]];
         }
         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 +969,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 +978,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;
@@ -968,6 +1022,12 @@ function refFromTypeReferenceNode(typeNode, source) {
         return;
     }
     const typeName = typeNode.typeName.text;
+    if (typeNode.typeArguments?.length) {
+        if (typeName !== 'Promise') {
+            throw new Error('TODO: handle type arguments');
+        }
+        return refFromTypeNode(typeNode.typeArguments[0], source);
+    }
     for (const statement of source.statements) {
         if (ts.isImportDeclaration(statement)) {
             // search imports
@@ -1107,21 +1167,23 @@ async function parse$1(path) {
     const scalarFnsInfos = {};
     const scalarTypeNodes = {};
     const sources = {};
-    for (const [name, { declaration, source }] of Object.entries((await parseModule(path)).exports)) {
-        sources[name] = source;
-        if (ts.isVariableDeclaration(declaration)) {
-            if (declaration.initializer && ts.isObjectLiteralExpression(declaration.initializer)) {
-                scalarFnsInfos[name] = scalarInfoFromObjectLiteralExpression(name, new URL(source.fileName).toString(), declaration.initializer.properties);
-            }
-        }
-        else if (ts.isTypeAliasDeclaration(declaration)) {
-            if (declaration.typeParameters?.length) {
-                console.log(`WARNING: skipping scalar type ${name}: type parameters are not supported`);
-                continue;
+    for (const [name, decls] of Object.entries((await parseModule(path)).exports)) {
+        for (const { declaration, source } of decls) {
+            sources[name] = source;
+            if (ts.isVariableDeclaration(declaration)) {
+                if (declaration.initializer && ts.isObjectLiteralExpression(declaration.initializer)) {
+                    scalarFnsInfos[name] = scalarInfoFromObjectLiteralExpression(name, new URL(source.fileName).toString(), declaration.initializer.properties);
+                }
             }
-            const ref = refFromTypeNode(declaration.type, source);
-            if (ref) {
-                scalarTypeNodes[name] = declaration.type;
+            else if (ts.isTypeAliasDeclaration(declaration)) {
+                if (declaration.typeParameters?.length) {
+                    console.log(`WARNING: skipping scalar type ${name}: type parameters are not supported`);
+                    continue;
+                }
+                const ref = refFromTypeNode(declaration.type, source);
+                if (ref) {
+                    scalarTypeNodes[name] = declaration.type;
+                }
             }
         }
     }
@@ -1134,7 +1196,7 @@ async function parse$1(path) {
             module: source.fileName,
             symbol: name,
         } : reconcileScalarType(name, [
-            fnsInfo?.serializeFunc?.declaration?.parameters?.[0]?.type,
+            // NOTE: omit serialize input type because it is supposed to be `unknown`
             fnsInfo?.parseValueFunc?.declaration?.type,
             fnsInfo?.parseLiteralFunc?.declaration?.type,
         ], source);
@@ -1517,9 +1579,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) {
@@ -36,23 +37,26 @@ async function findExports(source, resolveModuleFn = resolveModule) {
         if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) {
             if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
                 if (node.modifiers.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword)) {
-                    exports.default = { declaration: node, source, name: "default" };
+                    (exports.default || (exports.default = [])).push({ declaration: node, source, name: "default" });
                 }
                 else if (node.name) {
-                    exports[node.name.getText(source)] = { declaration: node, source, name: node.name.getText(source) };
+                    const name = node.name.getText(source);
+                    (exports[name] || (exports[name] = [])).push({ declaration: node, source, name: name });
                 }
             }
         }
         else if (ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isModuleDeclaration(node)) {
             if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
-                exports[node.name.getText(source)] = { declaration: node, source, name: node.name.getText(source) };
+                const name = node.name.getText(source);
+                (exports[name] || (exports[name] = [])).push({ declaration: node, source, name: name });
             }
         }
         else if (ts.isVariableStatement(node)) {
             if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
                 for (const decl of node.declarationList.declarations) {
                     if (decl.name) {
-                        exports[decl.name.getText(source)] = { declaration: decl, source, name: decl.name.getText(source) };
+                        const name = decl.name.getText(source);
+                        (exports[name] || (exports[name] = [])).push({ declaration: decl, source, name: name });
                     }
                 }
             }
@@ -70,7 +74,7 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                         if (!(name in moduleExports)) {
                             throw new Error(`Exported name ${name} not found in ${JSON.stringify(specifier)}`);
                         }
-                        exports[name] = moduleExports[name];
+                        (exports[name] || (exports[name] = [])).push(...moduleExports[name]);
                     }
                 }
                 else {
@@ -79,7 +83,6 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                             name: element.name.text,
                             property: element.propertyName?.text,
                         });
-                        // exports[element.name.getText(source)] = { declaration: element, source };
                     }
                 }
             }
@@ -95,57 +98,63 @@ async function findExports(source, resolveModuleFn = resolveModule) {
             if (ts.isVariableStatement(statement)) {
                 for (const decl of statement.declarationList.declarations) {
                     if (ts.isIdentifier(decl.name) && decl.name.getText(source) in names) {
-                        exports[names[decl.name.getText(source)]] = {
+                        const name = names[decl.name.getText(source)];
+                        (exports[name] || (exports[name] = [])).push({
                             declaration: decl,
                             source,
                             name: names[decl.name.getText(source)],
-                        };
+                        });
                     }
                 }
             }
             if (ts.isFunctionDeclaration(statement)) {
                 if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
-                    exports[names[statement.name.getText(source)]] = {
+                    const name = names[statement.name.getText(source)];
+                    (exports[name] || (exports[name] = [])).push({
                         declaration: statement,
                         source,
                         name: names[statement.name.getText(source)],
-                    };
+                    });
                 }
             }
             if (ts.isClassDeclaration(statement)) {
                 if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
-                    exports[names[statement.name.getText(source)]] = {
+                    const name = names[statement.name.getText(source)];
+                    (exports[name] || (exports[name] = [])).push({
                         declaration: statement,
                         source,
                         name: names[statement.name.getText(source)],
-                    };
+                    });
                 }
             }
             if (ts.isTypeAliasDeclaration(statement)) {
                 if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
-                    exports[names[statement.name.getText(source)]] = {
+                    const name = names[statement.name.getText(source)];
+                    (exports[name] || (exports[name] = [])).push({
                         declaration: statement,
                         source,
                         name: names[statement.name.getText(source)],
-                    };
+                    });
                 }
             }
             if (ts.isInterfaceDeclaration(statement)) {
                 if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
-                    exports[names[statement.name.getText(source)]] = {
+                    const name = names[statement.name.getText(source)];
+                    (exports[name] || (exports[name] = [])).push({
                         declaration: statement,
                         source,
                         name: names[statement.name.getText(source)],
-                    };
+                    });
                 }
             }
             if (ts.isEnumDeclaration(statement)) {
                 if (statement.name && ts.isIdentifier(statement.name) && statement.name.getText(source) in names) {
-                    exports[names[statement.name.getText(source)]] = {
+                    const name = names[statement.name.getText(source)];
+                    (exports[name] || (exports[name] = [])).push({
                         declaration: statement,
                         source,
                         name: names[statement.name.getText(source)],
-                    };
+                    });
                 }
             }
             if (ts.isImportDeclaration(statement)) {
@@ -165,11 +174,12 @@ async function findExports(source, resolveModuleFn = resolveModule) {
                             if (!importExports[element.name.getText(source)]) {
                                 throw new Error(`Exported name ${element.name.getText(source)} not found in ${JSON.stringify(statement.moduleSpecifier.getText(source))}`);
                             }
-                            exports[names[element.propertyName.getText(source)]] = {
+                            const name = names[element.propertyName.getText(source)];
+                            (exports[name] || (exports[name] = [])).push({
                                 declaration: element,
                                 source,
                                 name: names[element.propertyName.getText(source)],
-                            };
+                            });
                         }
                     }
                 }
@@ -236,16 +246,9 @@ function compareEntryKey([a], [b]) {
 function compareName({ name: a }, { name: b }) {
     return a.localeCompare(b);
 }
+const PRIMITIVE_TYPES = new Set(["ID", "Int", "Float", "String", "Boolean"]);
 function isPrimitiveType(type) {
-    switch (type.name) {
-        case "ID":
-        case "Int":
-        case "Float":
-        case "String":
-        case "Boolean":
-            return true;
-    }
-    return false;
+    return PRIMITIVE_TYPES.has(type.name);
 }
 function importAlias(line) {
     const pos = line.indexOf(" as ");
@@ -417,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$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 +502,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
@@ -739,6 +742,20 @@ class GeneratorContext {
                     .map((directive) => [directive.name, this._renderGraphQLDirectiveDefinition(directive)])
                     .sort(compareEntryKey),
             ].map(([, expr]) => expr),
+            ...Array.from(PRIMITIVE_TYPES)
+                .flatMap((type) => {
+                const info = this._scalarsInfo[type];
+                if (!info) {
+                    return [];
+                }
+                return [
+                    jen$1.statements(...[
+                        info.serializeFunc && this._gql("GraphQL" + type).dot("serialize").op("=").parens(renderSymbolReference(this._pkgs, info.serializeFunc).as.any),
+                        info.parseValueFunc && this._gql("GraphQL" + type).dot("parseValue").op("=").parens(renderSymbolReference(this._pkgs, info.parseValueFunc).as.any),
+                        info.parseLiteralFunc && this._gql("GraphQL" + type).dot("parseLiteral").op("=").parens(renderSymbolReference(this._pkgs, info.parseLiteralFunc).as.any),
+                    ].filter(Boolean))
+                ];
+            }),
             // render schema
             jen$1.const.id("schema").op("=").new.add(this._gql("GraphQLSchema")).call(jen$1.obj(...(schema.getQueryType()
                 ? [jen$1.prop("query", this._renderGraphQLTypeIdentifier(schema.getQueryType()))]
@@ -878,9 +895,44 @@ 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 }]) => {
+        .flatMap(([name, decls]) => decls.flatMap(({ declaration }) => {
         if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
             if (ts.isFunctionExpression(declaration.initializer)) {
                 return [[name, { module: path, symbol: name }]];
@@ -893,13 +945,14 @@ async function parseResolverFile(path) {
             return [[name, { module: path, symbol: name }]];
         }
         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 +967,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 +976,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;
@@ -966,6 +1020,12 @@ function refFromTypeReferenceNode(typeNode, source) {
         return;
     }
     const typeName = typeNode.typeName.text;
+    if (typeNode.typeArguments?.length) {
+        if (typeName !== 'Promise') {
+            throw new Error('TODO: handle type arguments');
+        }
+        return refFromTypeNode(typeNode.typeArguments[0], source);
+    }
     for (const statement of source.statements) {
         if (ts.isImportDeclaration(statement)) {
             // search imports
@@ -1105,21 +1165,23 @@ async function parse$1(path) {
     const scalarFnsInfos = {};
     const scalarTypeNodes = {};
     const sources = {};
-    for (const [name, { declaration, source }] of Object.entries((await parseModule(path)).exports)) {
-        sources[name] = source;
-        if (ts.isVariableDeclaration(declaration)) {
-            if (declaration.initializer && ts.isObjectLiteralExpression(declaration.initializer)) {
-                scalarFnsInfos[name] = scalarInfoFromObjectLiteralExpression(name, new URL(source.fileName).toString(), declaration.initializer.properties);
-            }
-        }
-        else if (ts.isTypeAliasDeclaration(declaration)) {
-            if (declaration.typeParameters?.length) {
-                console.log(`WARNING: skipping scalar type ${name}: type parameters are not supported`);
-                continue;
+    for (const [name, decls] of Object.entries((await parseModule(path)).exports)) {
+        for (const { declaration, source } of decls) {
+            sources[name] = source;
+            if (ts.isVariableDeclaration(declaration)) {
+                if (declaration.initializer && ts.isObjectLiteralExpression(declaration.initializer)) {
+                    scalarFnsInfos[name] = scalarInfoFromObjectLiteralExpression(name, new URL(source.fileName).toString(), declaration.initializer.properties);
+                }
             }
-            const ref = refFromTypeNode(declaration.type, source);
-            if (ref) {
-                scalarTypeNodes[name] = declaration.type;
+            else if (ts.isTypeAliasDeclaration(declaration)) {
+                if (declaration.typeParameters?.length) {
+                    console.log(`WARNING: skipping scalar type ${name}: type parameters are not supported`);
+                    continue;
+                }
+                const ref = refFromTypeNode(declaration.type, source);
+                if (ref) {
+                    scalarTypeNodes[name] = declaration.type;
+                }
             }
         }
     }
@@ -1132,7 +1194,7 @@ async function parse$1(path) {
             module: source.fileName,
             symbol: name,
         } : reconcileScalarType(name, [
-            fnsInfo?.serializeFunc?.declaration?.parameters?.[0]?.type,
+            // NOTE: omit serialize input type because it is supposed to be `unknown`
             fnsInfo?.parseValueFunc?.declaration?.type,
             fnsInfo?.parseLiteralFunc?.declaration?.type,
         ], source);
@@ -1515,9 +1577,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.3",
     "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"