eddev 2.0.0-beta.9 → 2.0.0-beta.91

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 } 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() {
@@ -223,10 +284,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"`,
+                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, {}],
@@ -334,6 +399,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] = ast;
+                }
+            }
+        }
+        return {
+            queries: result,
+            fragments: allFragments,
+        };
+    }
     /**
      * Validates a GraphQL manifest against a schema, ensuring there are no user errors.
      */
@@ -342,30 +470,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 || ""));
                         }
                     }
@@ -400,7 +541,7 @@ export class GraphQLGenerator {
             errors.push(String(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 +629,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>;

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-queries.js

@@ -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,7 @@ 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 {};

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,
             };
         },
     });