eddev 2.0.0-beta.21 → 2.0.0-beta.211

package/dist/node/graphql/graphql-codegen.js

@@ -1,5 +1,5 @@
 import { codegen } from "@graphql-codegen/core";
-import { Kind } from "graphql";
+import { Kind, visit, print, } from "graphql";
 import { NoUnusedFragmentsRule, specifiedRules, validate } from "graphql/validation/index.js";
 import { join, relative, resolve } from "path";
 import { ProjectEnvUtils } from "../project/env.js";
@@ -9,13 +9,15 @@ import { createGraphQLFileLoader } from "./query-files-loader.js";
 import * as typescriptPlugin from "@graphql-codegen/typescript";
 import * as typescriptOperationsPlugin from "@graphql-codegen/typescript-operations";
 import chalk from "chalk";
-import { code } from "ts-poet";
+import { code, imp } from "ts-poet";
 import { highlightCode } from "../utils/highlight-code.js";
 import { createConsole } from "../utils/stateful-log.js";
 import { watchFileTreeForChanges } from "../utils/watch-file-tree.js";
 import pluginFiles from "./plugins/gql-plugin-files.js";
 import pluginNoDuplicates from "./plugins/gql-plugin-no-duplicates.js";
 import pluginQueries from "./plugins/gql-plugin-queries.js";
+import { FSCodegen } from "../utils/fs-codegen.js";
+import { camelCase, pascalCase } from "change-case-all";
 export const graphqlLog = createConsole("GraphQL Codegen", "graphql");
 const console = graphqlLog;
 class GraphQLValidationError {
@@ -49,6 +51,7 @@ class GraphQLValidationError {
 }
 export class GraphQLGenerator {
     project;
+    opts;
     needsRegenerate = false;
     needsReload = true;
     regenerateReason = "";
@@ -56,12 +59,19 @@ export class GraphQLGenerator {
     isGenerating = false;
     schemaLoader;
     fileLoader;
+    optimizeWriter;
     debouncer;
     retryTimer;
-    constructor(project) {
+    constructor(project, opts) {
         this.project = project;
-        this.schemaLoader = new GraphQLSchemaLoader(ProjectEnvUtils.get("DEBUG_GRAPHQL_URL"));
+        this.opts = opts;
+        this.schemaLoader = new GraphQLSchemaLoader(ProjectEnvUtils.getSafe("DEBUG_GRAPHQL_URL"), ProjectEnvUtils.getSafe("SITE_API_KEY"));
         this.fileLoader = createGraphQLFileLoader(this.project, [
+            {
+                baseFolder: "queries/fragments",
+                pattern: "**/*.graphql",
+                key: "fragments",
+            },
             {
                 baseFolder: "blocks",
                 pattern: "**/*.graphql",
@@ -72,17 +82,44 @@ export class GraphQLGenerator {
                 pattern: "**/*.graphql",
                 key: "views",
             },
-            {
-                baseFolder: "queries/fragments",
-                pattern: "**/*.graphql",
-                key: "fragments",
-            },
             {
                 baseFolder: "queries",
                 pattern: "**/*.graphql",
                 key: "queries",
             },
         ]);
+        this.optimizeWriter = new FSCodegen(project, {
+            outDir: "./.eddev/queries",
+        });
+        this.optimizeWriter.register({
+            getFiles: async () => {
+                const files = await this.fileLoader.get();
+                const { queries, fragments } = this.getOptimizedQueries(files, true);
+                const optimizedQueries = Object.entries(queries).flatMap(([_, group]) => {
+                    return Object.entries(group).flatMap(([name, ast]) => {
+                        let content = [
+                            ast.leadingComments ? ast.leadingComments + "\n" : "",
+                            print(ast),
+                            ast.trailingComments ? "\n" + ast.trailingComments : "",
+                        ].join("");
+                        return {
+                            name,
+                            content,
+                        };
+                    });
+                });
+                return [
+                    ...optimizedQueries,
+                    {
+                        name: "fragments.json",
+                        content: JSON.stringify(Object.values(fragments).map(print), null, 2),
+                    },
+                ];
+            },
+            susbcribe: (callback) => {
+                return this.fileLoader.subscribe(callback);
+            },
+        });
     }
     async queueRegenerate(full, reason, info) {
         this.needsRegenerate = true;
@@ -107,14 +144,29 @@ export class GraphQLGenerator {
         // Do initial load of blocks
         await this.project.blocks.get();
         await this.project.views.get();
-        try {
-            await this.generate();
+        if (this.opts.generate) {
+            try {
+                await this.generate();
+            }
+            catch (err) { }
+        }
+        if (this.opts.watch) {
+            this.project.blocks.subscribeFuture(() => {
+                this.generateUtilTypes();
+            });
+            this.project.serverRoutes.subscribeFuture(() => {
+                this.generateAPITypes();
+            });
+            this.listen();
+        }
+        if (this.opts.optimize) {
+            if (this.opts.watch) {
+                await this.optimizeWriter.runAndWatch();
+            }
+            else {
+                await this.optimizeWriter.run();
+            }
         }
-        catch (err) { }
-        this.project.blocks.subscribeFuture(() => {
-            this.generateUtilTypes();
-        });
-        this.listen();
     }
     async listen() {
         // Subscribe to changes in block names
@@ -138,14 +190,23 @@ export class GraphQLGenerator {
             this.queueRegenerate(false, "GraphQL file(s) modifed", events?.map(stringifyFileEvent));
         });
         // Look out for PHP and acf-json file changes
-        watchFileTreeForChanges(["backend/**/*.php"], (event) => {
-            this.queueRegenerate(true, "PHP file change detected", stringifyFileEvent(event));
+        watchFileTreeForChanges({
+            pattern: ["backend/**/*.php"],
+            callback: (event) => {
+                this.queueRegenerate(true, "PHP file change detected", stringifyFileEvent(event));
+            },
         });
-        watchFileTreeForChanges(["vendor/**/*.php"], (change) => {
-            this.queueRegenerate(true, "PHP Vendor folder change detected", stringifyFileEvent(change));
+        watchFileTreeForChanges({
+            pattern: ["vendor/**/*.php"],
+            callback: (change) => {
+                this.queueRegenerate(true, "PHP Vendor folder change detected", stringifyFileEvent(change));
+            },
         });
-        watchFileTreeForChanges(["acf-json/**/*.json"], (change) => {
-            this.queueRegenerate(true, "ACF Field change detected", stringifyFileEvent(change));
+        watchFileTreeForChanges({
+            pattern: ["acf-json/**/*.json"],
+            callback: (change) => {
+                this.queueRegenerate(true, "ACF Field change detected", stringifyFileEvent(change));
+            },
         });
     }
     scheduleRetry() {
@@ -186,6 +247,19 @@ export class GraphQLGenerator {
         this.writeSchemaFile(schemaResult.schema);
         // Get GraphQL files
         const graphQLFiles = await this.fileLoader.get();
+        // Fill in any missing operation names
+        for (let [key, entry] of Object.entries(graphQLFiles.blocks)) {
+            if (entry.ast) {
+                const main = entry.ast.definitions[0];
+                if (main?.kind === Kind.OPERATION_DEFINITION && !main.name) {
+                    // @ts-ignore
+                    main.name = {
+                        kind: Kind.NAME,
+                        value: pascalCase(key.replace(".graphql", "").split(/\//).join("-")),
+                    };
+                }
+            }
+        }
         // Validate them against the schema
         const validationErrors = this.validateGraphQLFiles(graphQLFiles, schemaResult.rawSchema);
         if (validationErrors.length > 0) {
@@ -223,10 +297,14 @@ export class GraphQLGenerator {
         };
         const errors = (await Promise.all([
             this.generateUtilTypes(),
+            this.generateAPITypes(),
             this.generateTS("types.graphql.ts", schemaResult.rawSchema, {
                 documents: getDocuments(["queries", "views", "blocks", "fragments"]),
                 hasDocuments: true,
-                banner: `import { ContentBlock } from "eddev/blocks"`,
+                banner: [`import { ContentBlock } from "eddev/blocks"`, ...(wp.scalarTypeImports ?? [])].join("\n"),
+                footer: Object.keys(wp.scalarTypes)
+                    .map((name) => `export type ${name.endsWith("Option") ? name : name + "Scalar"} = Scalars["${name}"]["output"]`)
+                    .join("\n"),
                 plugins: {
                     typescript: [typescriptPlugin, {}],
                     typescriptOperations: [typescriptOperationsPlugin, {}],
@@ -269,7 +347,12 @@ export class GraphQLGenerator {
                     rootDir: this.project.rootDir,
                     folderName: "views",
                     globalName: "ViewProps",
-                    additionalTypes: {},
+                    additionalTypes: {
+                        _error: "ErrorRouteProps",
+                    },
+                    banner: `
+              import { ErrorRouteProps } from "eddev/routing"
+            `,
                 },
             }),
             this.generateTS("types.blocks.ts", schemaResult.rawSchema, {
@@ -287,7 +370,7 @@ export class GraphQLGenerator {
                     rootDir: this.project.rootDir,
                     globalName: "BlockProps",
                     folderName: "blocks",
-                    getType: (importedName, def) => {
+                    getType: (importedName, def, name) => {
                         // const queryKeyVals: any[] = []
                         let blockSelection = "";
                         let hasOthers = false;
@@ -309,6 +392,13 @@ export class GraphQLGenerator {
                             return {};
                         return type.join(" & ");
                     },
+                    additionalTypes: Object.fromEntries(Object.entries(blockManifest.blocks).map(([key, block]) => {
+                        const styleNames = new Set(block.blockStyles
+                            ?.map((s) => s.name)
+                            .filter(Boolean)
+                            .map((name) => JSON.stringify(name)) ?? []);
+                        return [key, styleNames.size > 0 ? `{ "blockStyle": ${[...styleNames].join("|")} }` : null];
+                    })),
                 },
             }),
             this.generateTS("hooks/queries.ts", schemaResult.rawSchema, {
@@ -334,6 +424,69 @@ export class GraphQLGenerator {
             this.generate();
         }
     }
+    getOptimizedQueries(graphQLFiles, rewrite = false) {
+        const result = {};
+        const allFragments = {};
+        /**
+         * Get all the base fragment definitions
+         */
+        const baseFragments = new Map();
+        Object.values(graphQLFiles.fragments)
+            .map((file) => file?.ast?.definitions ?? [])
+            .filter((def) => def.length > 0)
+            .flat()
+            .filter((n) => n.kind === Kind.FRAGMENT_DEFINITION)
+            .forEach((node) => baseFragments.set(node.name.value, node));
+        baseFragments.forEach((node) => {
+            allFragments[node.name.value] = node;
+        });
+        function findFragments(defs, map = new Map()) {
+            // console.log("findFragments", defs.length)
+            for (let def of defs) {
+                if (def.kind === Kind.FRAGMENT_DEFINITION) {
+                    map.set(def.name.value, def);
+                }
+            }
+            for (let def of defs) {
+                visit(def, {
+                    FragmentSpread: {
+                        enter: (node) => {
+                            const match = baseFragments.get(node.name.value);
+                            if (match && !map.has(node.name.value)) {
+                                map.set(node.name.value, match);
+                                findFragments([match], map);
+                            }
+                        },
+                    },
+                });
+            }
+            return {
+                fragments: [...map.values()],
+                definitions: defs.filter((n) => n.kind !== Kind.FRAGMENT_DEFINITION),
+            };
+        }
+        for (let [groupName, fileMap] of Object.entries(graphQLFiles)) {
+            result[groupName] = {};
+            for (let [path, file] of Object.entries(fileMap)) {
+                if (!file.parseError) {
+                    // Find all fragments
+                    const { fragments, definitions } = findFragments(file?.ast?.definitions ?? []);
+                    const ast = {
+                        kind: Kind.DOCUMENT,
+                        definitions: [...definitions, ...fragments],
+                        loc: file.ast.loc,
+                        leadingComments: file.leadingComments,
+                        trailingComments: file.trailingComments,
+                    };
+                    result[groupName][path.replace(".graphql", ".txt")] = ast;
+                }
+            }
+        }
+        return {
+            queries: result,
+            fragments: allFragments,
+        };
+    }
     /**
      * Validates a GraphQL manifest against a schema, ensuring there are no user errors.
      */
@@ -342,30 +495,43 @@ export class GraphQLGenerator {
          * Use all rules, except for No Unused Fragments — since we prepend those fragments to every test
          */
         const validationRules = specifiedRules.filter((rule) => rule !== NoUnusedFragmentsRule);
+        /**
+         * Get the optimized files — queries with all fragments included
+         */
+        const { queries } = this.getOptimizedQueries(graphQLFiles);
+        /**
+         * Only report the same error once (mostly for preventing repeats of the same fragment errors)
+         */
+        const errorsShown = new Map();
         /**
          * Validate everything
          */
         const report = [];
         for (let [groupName, fileMap] of Object.entries(graphQLFiles)) {
+            const group = queries[groupName];
             for (let [path, file] of Object.entries(fileMap)) {
                 if (file.parseError) {
                     report.push(new GraphQLValidationError(file.parseError.message, path, file.parseError.line, file.parseError.column, file.contents));
                 }
                 else {
                     // Find all fragments
-                    const fragments = Object.values(graphQLFiles.fragments)
-                        .map((file) => file.ast.definitions)
-                        .filter((def) => def.length > 0)
-                        .filter((def) => def !== file.ast.definitions)
-                        .flat();
-                    const validationAST = {
-                        kind: Kind.DOCUMENT,
-                        definitions: [...fragments, ...file.ast.definitions],
-                        loc: file.ast.loc,
-                    };
+                    const validationAST = group[path];
+                    if (!validationAST) {
+                        continue;
+                    }
                     const errors = validate(schema, validationAST, validationRules);
                     if (errors.length > 0) {
                         for (let error of errors) {
+                            if (error.nodes && error.nodes[0]) {
+                                const node = error.nodes[0];
+                                if (errorsShown.has(node) && errorsShown.get(node)?.includes(error.message)) {
+                                    continue;
+                                }
+                                else {
+                                    errorsShown.set(node, [...(errorsShown.get(node) ?? []), error.message]);
+                                }
+                            }
+                            // console.log(error.nodes?.map((n) => n.kind))
                             report.push(new GraphQLValidationError(error.message, path, error.locations?.[0].line || 1, error.locations?.[0].column || 1, error.source?.body || ""));
                         }
                     }
@@ -397,10 +563,10 @@ export class GraphQLGenerator {
             output = await codegen(config);
         }
         catch (err) {
-            errors.push(String(err));
+            errors.push(err);
         }
         if (args.banner) {
-            output = args.banner + "\n\n" + output;
+            output = args.banner + "\n\n" + output + "\n" + (args.footer ?? "");
         }
         if (errors.length === 0) {
             const didWrite = await fs.writeIfUnchanged(config.filename, output);
@@ -488,6 +654,42 @@ export class GraphQLGenerator {
         }
         return [];
     }
+    async generateAPITypes() {
+        const filename = join(this.project.rootDir, "types.api.ts");
+        try {
+            const routeManifest = await this.project.serverRoutes.get();
+            const contents = code /*ts*/ `
+        import "eddev/types.app.public";
+        import { InferRPCServerContext, rpc } from "eddev/server"
+        import { finalizeRPCRouter } from "eddev/_internal"
+        ${routeManifest.contextFileName
+                ? code /*ts*/ `
+          import createContext from "./${routeManifest.contextFileName.replace(/\.tsx?$/, "")}"
+        `
+                : code /*ts*/ `
+          const createContext = () => ({})
+        `}
+
+        function createRouter() {
+          return finalizeRPCRouter({${Object.entries(routeManifest.routes).map(([name, route]) => {
+                const src = "./" + route.fileName;
+                const importStatement = imp(camelCase(name) + "=" + src.replace(/\.tsx?$/, ""));
+                return code `${JSON.stringify(route.prefix)}: ${importStatement},\n`;
+            })}})
+        }
+
+        declare global {
+          interface RPCContext extends InferRPCServerContext<typeof createContext> {}
+          interface RPCRouter extends ReturnType<typeof createRouter> {}
+        }
+      `;
+            await fs.writeIfUnchanged(filename, contents.toString());
+        }
+        catch (err) {
+            return [err];
+        }
+        return [];
+    }
     /**
      * Saves the schema to a file, for use by the VSCode GraphQL extension
      */

package/dist/node/graphql/graphql-schema-loader.d.ts

@@ -6,8 +6,9 @@ type LoadResult = {
 };
 export declare class GraphQLSchemaLoader {
     url: string;
+    apiKey?: string | undefined;
     lastHash: string;
-    constructor(url: string);
+    constructor(url: string, apiKey?: string | undefined);
     private cachedResult;
     get(forceReload?: boolean): Promise<Error | LoadResult>;
     load(): Promise<Error | LoadResult>;
@@ -15,3 +16,4 @@ export declare class GraphQLSchemaLoader {
     private processSchema;
 }
 export {};
+//# sourceMappingURL=graphql-schema-loader.d.ts.map

package/dist/node/graphql/graphql-schema-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql-schema-loader.d.ts","sourceRoot":"","sources":["../../../src/node/graphql/graphql-schema-loader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAA2B,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAOpF,KAAK,UAAU,GAAG;IAChB,MAAM,EAAE,kBAAkB,CAAA;IAC1B,SAAS,EAAE,aAAa,CAAA;IACxB,UAAU,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,qBAAa,mBAAmB;IAGrB,GAAG,EAAE,MAAM;IACX,MAAM,CAAC,EAAE,MAAM;IAHxB,QAAQ,SAAK;gBAEJ,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,MAAM,YAAA;IAGxB,OAAO,CAAC,YAAY,CAA0B;IAExC,GAAG,CAAC,WAAW,UAAQ;IAOvB,IAAI;IAgCV,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,aAAa;CA4BtB"}

package/dist/node/graphql/graphql-schema-loader.js

@@ -4,11 +4,14 @@ import { introspectionFromSchema } from "graphql";
 import { graphqlLog as console } from "./graphql-codegen.js";
 import chalk from "chalk";
 import { hash } from "object-code";
+import { fetchWP } from "../utils/fetch-wp.js";
 export class GraphQLSchemaLoader {
     url;
+    apiKey;
     lastHash = "";
-    constructor(url) {
+    constructor(url, apiKey) {
         this.url = url;
+        this.apiKey = apiKey;
     }
     cachedResult = null;
     async get(forceReload = false) {
@@ -21,21 +24,7 @@ export class GraphQLSchemaLoader {
         console.info(`${this.lastHash ? "Reloading" : "Loading"} GraphQL schema from ${chalk.yellowBright(this.url)}`);
         const rawSchema = await loadSchema(this.url, {
             loaders: [new UrlLoader()],
-            // fetch: (url: string, opts: any) => {
-            //   const httpsAgent = new Agent({
-            //     rejectUnauthorized: false,
-            //   })
-            //   return fetch(url, {
-            //     ...opts,
-            //     agent: function (_parsedURL) {
-            //       if (_parsedURL.protocol == "http:") {
-            //         return undefined
-            //       } else {
-            //         return httpsAgent
-            //       }
-            //     },
-            //   })
-            // },
+            fetch: fetchWP,
         }).catch((e) => {
             return e;
         });

package/dist/node/graphql/plugins/gql-plugin-files.d.ts

@@ -3,12 +3,14 @@ type PluginConfig = {
     rootDir: string;
     fallbackType: string;
     globalName: string;
-    getType?: (importedName: string, definition: any) => string;
+    getType?: (importedName: string, definition: any, name: string) => string;
     additionalTypes: {
         [key: string]: string;
     };
+    banner: string;
 };
 declare const _default: {
     plugin: (schema: any, documents: any, config: PluginConfig, info: any) => string;
 };
 export default _default;
+//# sourceMappingURL=gql-plugin-files.d.ts.map

package/dist/node/graphql/plugins/gql-plugin-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gql-plugin-files.d.ts","sourceRoot":"","sources":["../../../../src/node/graphql/plugins/gql-plugin-files.ts"],"names":[],"mappings":"AAIA,KAAK,YAAY,GAAG;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;IACzE,eAAe,EAAE;QACf,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KACtB,CAAA;IACD,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;;qBAGkB,GAAG,aAAa,GAAG,UAAU,YAAY,QAAQ,GAAG;;AADvE,wBAkEC"}

package/dist/node/graphql/plugins/gql-plugin-files.js

@@ -31,9 +31,9 @@ export default {
             filesFound[relative.replace(/\.graphql/, "")] = true;
             if (relative && doc.document.definitions.length) {
                 let importedName = doc.document.definitions[0].name.value + "Query";
-                let typeName = config.getType?.(importedName, doc.document.definitions[0]) || importedName;
-                imports.push(importedName);
                 const key = relative.replace(/\.graphql/, "");
+                let typeName = config.getType?.(importedName, doc.document.definitions[0], key) || importedName;
+                imports.push(importedName);
                 items.push(`${JSON.stringify(key)}: ${typeForFile(key, typeName)}`);
             }
         });
@@ -51,6 +51,7 @@ export default {
        */
       import 'eddev/types.app.public'
       ${imports.length > 0 ? code `import { ${imports.sort().join(", ")} } from "./types.graphql"` : ""}
+      ${config.banner || ""}
 
       declare global {
         interface ${config.globalName} {

package/dist/node/graphql/plugins/gql-plugin-no-duplicates.d.ts

@@ -6,3 +6,4 @@ declare const _default: {
     validate: (schema: any, documents: any, config: PluginConfig, info: any) => void;
 };
 export default _default;
+//# sourceMappingURL=gql-plugin-no-duplicates.d.ts.map

package/dist/node/graphql/plugins/gql-plugin-no-duplicates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gql-plugin-no-duplicates.d.ts","sourceRoot":"","sources":["../../../../src/node/graphql/plugins/gql-plugin-no-duplicates.ts"],"names":[],"mappings":"AAAA,KAAK,YAAY,GAAG;IAClB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;;;uBAIoB,GAAG,aAAa,GAAG,UAAU,YAAY,QAAQ,GAAG;;AAFzE,wBASC"}

package/dist/node/graphql/plugins/gql-plugin-queries.d.ts

@@ -6,3 +6,4 @@ declare const _default: {
     plugin: (schema: any, documents: any, config: PluginConfig, info: any) => string;
 };
 export default _default;
+//# sourceMappingURL=gql-plugin-queries.d.ts.map

package/dist/node/graphql/plugins/gql-plugin-queries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gql-plugin-queries.d.ts","sourceRoot":"","sources":["../../../../src/node/graphql/plugins/gql-plugin-queries.ts"],"names":[],"mappings":"AAWA,KAAK,YAAY,GAAG;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;;qBAKkB,GAAG,aAAa,GAAG,UAAU,YAAY,QAAQ,GAAG;;AADvE,wBA2TC"}

package/dist/node/graphql/plugins/gql-plugin-queries.js

@@ -1,6 +1,6 @@
 import { printSourceLocation, visit, } from "graphql";
-import { code, imp } from "ts-poet";
 import { basename } from "path";
+import { code, imp } from "ts-poet";
 export default {
     plugin: (schema, documents, config, info) => {
         const hooks = {};
@@ -67,7 +67,7 @@ export default {
                     // Another convention, the query name and file name should be the same
                     const baseName = basename(fileName);
                     if (baseName.replace(".graphql", "") !== name) {
-                        throwErrorAtLocation(item.name.loc, `Expected your query name and file name to match, for conventions sake (eg. '${baseName}' should be '${name}.graphql')`);
+                        throwErrorAtLocation(item.name.loc, `Expected GraphQL operation name to match the filename.\nYou should either:\na) rename the file to '${name}.graphql'\nb) rename the operation to '${baseName}'`);
                     }
                     // Only import variables if the operation has variables
                     if (variablesTypeName) {

package/dist/node/graphql/query-files-loader.d.ts

@@ -10,6 +10,8 @@ type Entry = {
         line?: number;
         column?: number;
     } | null;
+    leadingComments?: string;
+    trailingComments?: string;
 };
 export type GraphQLManifest<TKeys extends string> = {
     [K in TKeys]: {
@@ -21,6 +23,8 @@ type PatternMap<TKeys extends string> = {
     key: TKeys;
     baseFolder: string;
     pattern: string;
+    ignore?: string[];
 }[];
 export declare function createGraphQLFileLoader<TKeys extends string>(project: Project, patterns: PatternMap<TKeys>): import("../project/manifest/manifest.js").ManifestGenerator<Entry, GraphQLManifest<TKeys>>;
 export {};
+//# sourceMappingURL=query-files-loader.d.ts.map

package/dist/node/graphql/query-files-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-files-loader.d.ts","sourceRoot":"","sources":["../../../src/node/graphql/query-files-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAS,MAAM,SAAS,CAAA;AAI7C,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAG/C,KAAK,KAAK,GAAG;IACX,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,YAAY,CAAA;IACjB,UAAU,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IACtE,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,eAAe,CAAC,KAAK,SAAS,MAAM,IAAI;KACjD,CAAC,IAAI,KAAK,GAAG;QACZ,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAA;KACrB;CACF,CAAA;AAED,MAAM,MAAM,iBAAiB,CAAC,KAAK,SAAS,MAAM,IAAI,UAAU,CAAC,OAAO,uBAAuB,CAAC,KAAK,CAAC,CAAC,CAAA;AAEvG,KAAK,UAAU,CAAC,KAAK,SAAS,MAAM,IAAI;IACtC,GAAG,EAAE,KAAK,CAAA;IACV,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;CAClB,EAAE,CAAA;AAEH,wBAAgB,uBAAuB,CAAC,KAAK,SAAS,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,CAAC,KAAK,CAAC,8FAyD1G"}

package/dist/node/graphql/query-files-loader.js

@@ -7,6 +7,7 @@ export function createGraphQLFileLoader(project, patterns) {
     return createManifestGenerator({
         baseDir: project.rootDir,
         pattern: patterns.map((p) => join(p.baseFolder, p.pattern)),
+        ignore: patterns.flatMap((p) => p.ignore?.map((ignore) => join(p.baseFolder, ignore)) ?? []),
         watch: cliMode.watch,
         async generateManifest(entries) {
             let result = {};
@@ -32,6 +33,8 @@ export function createGraphQLFileLoader(project, patterns) {
             const contents = await fs.readFile(path, "utf8");
             let ast = null;
             let parseError = null;
+            const leadingComments = contents.match(/^(\n|#[^\n]*)+\n/)?.[0].trim();
+            const trailingComments = contents.match(/(\n|#[^\n]*)+$/)?.[0].trim();
             try {
                 ast = parse(contents);
             }
@@ -48,6 +51,8 @@ export function createGraphQLFileLoader(project, patterns) {
                 contents,
                 ast,
                 parseError,
+                leadingComments,
+                trailingComments,
             };
         },
     });

package/dist/node/graphql/wp-info-query.d.ts

@@ -1 +1,2 @@
 export declare const WPInfoQuery = "\n  query WPInfo {\n    contentTypes(first: 100) {\n      nodes {\n        name\n        label\n        hasArchive\n        graphqlSingleName\n        graphqlPluralName\n        excludeFromSearch\n      }\n    }\n    taxonomies(first: 100) {\n      nodes {\n        graphqlPluralName\n        graphqlSingleName\n        name\n        label\n      }\n    }\n    plugins(first: 100) {\n      nodes {\n        name\n        pluginUri\n        version\n      }\n    }\n  }\n";
+//# sourceMappingURL=wp-info-query.d.ts.map

package/dist/node/graphql/wp-info-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wp-info-query.d.ts","sourceRoot":"","sources":["../../../src/node/graphql/wp-info-query.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,2dA4BvB,CAAA"}