eddev 0.3.35 → 2.0.0-beta.1

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

@@ -0,0 +1,503 @@
+import { codegen } from "@graphql-codegen/core";
+import { Kind } from "graphql";
+import { NoUnusedFragmentsRule, specifiedRules, validate } from "graphql/validation/index.js";
+import { join, relative, resolve } from "path";
+import { ProjectEnvUtils } from "../project/env.js";
+import { fs } from "../utils/fs.js";
+import { GraphQLSchemaLoader } from "./graphql-schema-loader.js";
+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 { highlightCode } from "../utils/highlightCode.js";
+import { createConsole } from "../utils/statefulLog.js";
+import { watchFileTreeForChanges } from "../utils/watchFileTree.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";
+export const graphqlLog = createConsole("GraphQL Codegen", "graphql");
+const console = graphqlLog;
+class GraphQLValidationError {
+    message;
+    path;
+    line;
+    col;
+    source;
+    constructor(message, path, line, col, source) {
+        this.message = message;
+        this.path = path;
+        this.line = line;
+        this.col = col;
+        this.source = source;
+    }
+    toString() {
+        return this.format();
+    }
+    format() {
+        return highlightCode({
+            fileName: this.path,
+            code: this.source,
+            language: "graphql",
+            error: this.message,
+            pointTo: {
+                column: this.col,
+                line: this.line,
+            },
+        });
+    }
+}
+export class GraphQLGenerator {
+    project;
+    needsRegenerate = false;
+    needsReload = true;
+    regenerateReason = "";
+    regenerateReasonInfo = [];
+    isGenerating = false;
+    schemaLoader;
+    fileLoader;
+    debouncer;
+    retryTimer;
+    constructor(project) {
+        this.project = project;
+        this.schemaLoader = new GraphQLSchemaLoader(ProjectEnvUtils.get("DEBUG_GRAPHQL_URL"));
+        this.fileLoader = createGraphQLFileLoader(this.project, [
+            {
+                baseFolder: "blocks",
+                pattern: "**/*.graphql",
+                key: "blocks",
+            },
+            {
+                baseFolder: "views",
+                pattern: "**/*.graphql",
+                key: "views",
+            },
+            {
+                baseFolder: "queries/fragments",
+                pattern: "**/*.graphql",
+                key: "fragments",
+            },
+            {
+                baseFolder: "queries",
+                pattern: "**/*.graphql",
+                key: "queries",
+            },
+        ]);
+    }
+    async queueRegenerate(full, reason, info) {
+        this.needsRegenerate = true;
+        if (full)
+            this.needsReload = true;
+        this.regenerateReason = reason;
+        if (info) {
+            this.regenerateReasonInfo.push(...(Array.isArray(info) ? info : [info]));
+        }
+        clearTimeout(this.debouncer);
+        clearTimeout(this.retryTimer);
+        this.debouncer = setTimeout(async () => {
+            if (this.isGenerating)
+                return;
+            this.isGenerating = true;
+            this.generate().finally(() => {
+                this.isGenerating = false;
+            });
+        }, 50);
+    }
+    async start() {
+        // Do initial load of blocks
+        await this.project.blocks.get();
+        await this.project.views.get();
+        try {
+            await this.generate();
+        }
+        catch (err) { }
+        this.project.blocks.subscribeFuture(() => {
+            this.generateUtilTypes();
+        });
+        this.listen();
+    }
+    async listen() {
+        // Subscribe to changes in block names
+        this.project.blocks.subscribeFuture((manifest, changes) => {
+            const updates = changes?.filter((change) => change.type !== "changed");
+            if (updates?.length) {
+                this.queueRegenerate(true, "Block component manifest was updated", updates?.map(stringifyFileEvent));
+            }
+        });
+        this.project.views.subscribeFuture((manifest, changes) => {
+            const updates = changes?.filter((change) => change.type !== "changed");
+            if (updates?.length) {
+                this.queueRegenerate(true, "View component manifest was updates", updates?.map(stringifyFileEvent));
+            }
+        });
+        function stringifyFileEvent(event) {
+            return `[${chalk.yellow(event.type)}] ${chalk.yellowBright(event.file)}`;
+        }
+        // Subscribe to Query files
+        this.fileLoader.subscribeFuture((manifest, events) => {
+            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(["vendor/**/*.php"], (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));
+        });
+    }
+    scheduleRetry() {
+        clearTimeout(this.retryTimer);
+        this.retryTimer = setTimeout(() => {
+            this.queueRegenerate(true, "Retrying...");
+        }, 5000);
+    }
+    async generate() {
+        clearTimeout(this.retryTimer);
+        console.resetLog();
+        console.setWorking(true);
+        // Print out the reason for the generation
+        if (this.needsRegenerate) {
+            const reasonInfo = this.regenerateReasonInfo.length > 0 ? "\n" + this.regenerateReasonInfo.map((f) => "- " + f).join("\n") : "";
+            if (this.regenerateReason) {
+                console.info("Regenerating: " + this.regenerateReason + reasonInfo);
+            }
+            this.needsRegenerate = false;
+            this.regenerateReason = "";
+            this.regenerateReasonInfo = [];
+        }
+        // Get blocks and views
+        const blockManifest = await this.project.blocks.get();
+        const viewManifest = await this.project.views.get();
+        // Get WP basics
+        const wp = await this.project.getWordpressInfo();
+        // Load the schema
+        const schemaResult = await this.schemaLoader.get(this.needsReload);
+        this.needsReload = false;
+        if (schemaResult instanceof Error) {
+            console.error(`Failed to load schema:`, schemaResult);
+            console.help("Is the WordPress server running?");
+            console.setWorking(false);
+            this.scheduleRetry();
+            return;
+        }
+        this.writeSchemaFile(schemaResult.schema);
+        // Get GraphQL files
+        const graphQLFiles = await this.fileLoader.get();
+        // Validate them against the schema
+        const validationErrors = this.validateGraphQLFiles(graphQLFiles, schemaResult.rawSchema);
+        if (validationErrors.length > 0) {
+            console.startGroup("GraphQL document validation failed", "error");
+            validationErrors.forEach((err) => {
+                console.fail(err.format());
+            });
+            console.endGroup();
+            console.help("Please fix the above error(s) to continue");
+            console.setWorking(false);
+            return;
+        }
+        const getDocuments = (keys) => {
+            const result = [];
+            for (const key of keys) {
+                const group = graphQLFiles[key];
+                for (const [_, entry] of Object.entries(group).sort((a, b) => a[0].localeCompare(b[0]))) {
+                    result.push({
+                        document: entry.ast,
+                        rawDSL: entry.contents,
+                        location: entry.path,
+                    });
+                }
+            }
+            return result;
+        };
+        const hasDocuments = (keys) => {
+            for (const key of keys) {
+                const group = graphQLFiles[key];
+                if (Object.keys(group).length > 0) {
+                    return true;
+                }
+            }
+            return false;
+        };
+        const errors = (await Promise.all([
+            this.generateUtilTypes(),
+            this.generateTS("types.graphql.ts", schemaResult.rawSchema, {
+                documents: getDocuments(["queries", "views", "blocks", "fragments"]),
+                hasDocuments: true,
+                banner: `import { ContentBlock } from "eddev/blocks"`,
+                plugins: {
+                    typescript: [typescriptPlugin, {}],
+                    typescriptOperations: [typescriptOperationsPlugin, {}],
+                    noDuplicates: [pluginNoDuplicates, {}],
+                },
+                config: {
+                    // maybeValue: "T",
+                    avoidOptionals: {
+                        field: true,
+                        inputValue: false,
+                        object: false,
+                        defaultValue: false,
+                    },
+                    exportFragmentSpreadSubTypes: true,
+                    // exportFragmentSpreadSubTypes: true,
+                    inlineFragmentTypes: "combine",
+                    scalars: {
+                        ContentBlocks: "ContentBlock[]",
+                        ...wp.scalarTypes,
+                    },
+                    onlyOperationTypes: true,
+                    skipTypename: true,
+                    preResolveTypes: true,
+                    maybeValue: "T | null",
+                    inputMaybeValue: "T | null | undefined",
+                }, // satisfies TypeScriptPluginConfig & TypeScriptDocumentsPluginConfig,
+            }),
+            this.generateTS("types.views.ts", schemaResult.rawSchema, {
+                documents: getDocuments(["views", "fragments"]),
+                hasDocuments: hasDocuments(["views"]),
+                plugins: {
+                    files: [
+                        pluginFiles,
+                        {
+                            names: Object.keys(viewManifest.views),
+                        },
+                    ],
+                },
+                config: {
+                    rootDir: this.project.rootDir,
+                    folderName: "views",
+                    globalName: "ViewProps",
+                    additionalTypes: {},
+                },
+            }),
+            this.generateTS("types.blocks.ts", schemaResult.rawSchema, {
+                documents: getDocuments(["blocks", "fragments"]),
+                hasDocuments: hasDocuments(["blocks"]),
+                plugins: {
+                    files: [
+                        pluginFiles,
+                        {
+                            names: Object.keys(blockManifest.blocks),
+                        },
+                    ],
+                },
+                config: {
+                    rootDir: this.project.rootDir,
+                    globalName: "BlockProps",
+                    folderName: "blocks",
+                    getType: (importedName, def) => {
+                        // const queryKeyVals: any[] = []
+                        let blockSelection = "";
+                        let hasOthers = false;
+                        for (const item of def.selectionSet.selections) {
+                            if (item.name.value === "block") {
+                                const blockField = item?.selectionSet?.selections[0]?.name?.value;
+                                blockSelection = `Exclude<${importedName}["block"][${JSON.stringify(blockField)}], null | undefined>`;
+                            }
+                            else {
+                                hasOthers = true;
+                            }
+                        }
+                        const type = [];
+                        if (hasOthers)
+                            type.push(`Omit<${importedName}, 'block'>`);
+                        if (blockSelection)
+                            type.push(blockSelection);
+                        if (type.length === 0)
+                            return {};
+                        return type.join(" & ");
+                    },
+                },
+            }),
+            this.generateTS("hooks/queries.ts", schemaResult.rawSchema, {
+                documents: getDocuments(["queries"]),
+                hasDocuments: true,
+                plugins: {
+                    queries: [pluginQueries, {}],
+                },
+                config: {
+                    rootDir: this.project.rootDir,
+                },
+            }),
+        ])).flat();
+        if (errors.length > 0) {
+            errors.forEach((err) => {
+                console.fail(err);
+            });
+        }
+        console.success("Generated TypeScript definitions");
+        console.setWorking(false);
+        // If a regeneration request has come through, start again!
+        if (this.needsRegenerate) {
+            this.generate();
+        }
+    }
+    /**
+     * Validates a GraphQL manifest against a schema, ensuring there are no user errors.
+     */
+    validateGraphQLFiles(graphQLFiles, schema) {
+        /**
+         * Use all rules, except for No Unused Fragments — since we prepend those fragments to every test
+         */
+        const validationRules = specifiedRules.filter((rule) => rule !== NoUnusedFragmentsRule);
+        /**
+         * Validate everything
+         */
+        const report = [];
+        for (let [groupName, fileMap] of Object.entries(graphQLFiles)) {
+            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 errors = validate(schema, validationAST, validationRules);
+                    if (errors.length > 0) {
+                        for (let error of errors) {
+                            report.push(new GraphQLValidationError(error.message, path, error.locations?.[0].line || 1, error.locations?.[0].column || 1, error.source?.body || ""));
+                        }
+                    }
+                }
+            }
+        }
+        return report;
+    }
+    async generateTS(fileName, schema, args) {
+        const config = {
+            schema,
+            documents: args.documents,
+            hasDocuments: args.hasDocuments,
+            plugins: [],
+            pluginMap: {},
+            filename: join(this.project.rootDir, fileName),
+            skipDocumentsValidation: true,
+            config: args.config,
+        };
+        const errors = [];
+        Object.entries(args.plugins).forEach(([key, [plugin, options]]) => {
+            config.plugins.push({
+                [key]: options,
+            });
+            config.pluginMap[key] = plugin;
+        });
+        let output = "export {}";
+        try {
+            output = await codegen(config);
+        }
+        catch (err) {
+            errors.push(String(err));
+        }
+        if (args.banner) {
+            output = args.banner + "\n\n" + output;
+        }
+        if (errors.length === 0) {
+            const didWrite = await fs.writeIfUnchanged(config.filename, output);
+            if (didWrite) {
+                console.info("Updated " + relative(this.project.rootDir, config.filename));
+            }
+        }
+        return errors;
+    }
+    async generateUtilTypes() {
+        const filename = join(this.project.rootDir, "types.util.ts");
+        try {
+            const wpInfo = await this.project.getWordpressInfo();
+            const views = await this.project.views.get();
+            const blocks = await this.project.blocks.get();
+            const pageTemplates = Object.values(views.views).filter((view) => view.isCustomTemplate);
+            const blockTags = new Set(wpInfo.blockTags ?? []);
+            const blockFlags = new Map();
+            for (let block of Object.values(blocks.blocks)) {
+                block.tags?.forEach((tag) => blockTags.add(tag));
+                if (block.flags) {
+                    for (let key in block.flags) {
+                        if (!blockFlags.has(key))
+                            blockFlags.set(key, new Set());
+                        blockFlags.get(key).add(JSON.stringify(block.flags[key]));
+                    }
+                }
+            }
+            const postMetaTypes = {};
+            wpInfo.postMetaTypes.forEach((meta) => {
+                postMetaTypes[meta.key] ??= [];
+                if (meta.isScalar) {
+                    postMetaTypes[meta.key].push('Scalars["' + meta.typeName + '"]["input"]');
+                }
+                else {
+                    postMetaTypes[meta.key].push(meta.typeName);
+                }
+                postMetaTypes[meta.key].sort();
+            });
+            const contents = code `
+        import "eddev/types.app.public";
+        import type { Scalars } from "./types.graphql";
+
+        declare global {
+          interface PostTypes {
+            ${Object.entries(wpInfo.postTypes)
+                .map(([name, type]) => code `${JSON.stringify(name)}: ${JSON.stringify(type)}`)
+                .join(";")}
+          }
+          interface PageTemplates {
+            ${pageTemplates
+                .map((template) => code `${JSON.stringify(template.slug)}: ${JSON.stringify(template.slug)}`)
+                .join(";")}
+          }
+          interface CoreBlockProps {
+            ${wpInfo.coreBlocks
+                .sort()
+                .map((name) => code `${JSON.stringify(name)}: {[K: string]: any}`)
+                .join(";")}
+          }
+          interface DefinedBlockTags {
+            ${[...blockTags]
+                .sort()
+                .map((name) => code `${JSON.stringify(name)}: ${JSON.stringify(name)}`)
+                .join(";")}
+          }
+          interface DefinedBlockFlags {
+            ${[...blockFlags.entries()]
+                .sort()
+                .map(([name, values]) => code `${JSON.stringify(name)}: ${[...values].join(" | ")}`)
+                .join(";")}
+          }
+          interface PostMetaTypes {
+            ${[...Object.keys(postMetaTypes)]
+                .sort()
+                .map((name) => code `${JSON.stringify(name)}: ${postMetaTypes[name].join(" | ")}`)
+                .join(";")}
+          }
+        }
+      `;
+            await fs.writeIfUnchanged(filename, contents.toString());
+        }
+        catch (err) {
+            return [err];
+        }
+        return [];
+    }
+    /**
+     * Saves the schema to a file, for use by the VSCode GraphQL extension
+     */
+    async writeSchemaFile(schema) {
+        let didWrite = await fs.writeJsonIfUnchanged(resolve(this.project.rootDir, "schema.json"), schema, false);
+        if (didWrite) {
+            console.info("Writing schema file for VSCode");
+        }
+        else {
+            console.info("GraphQL schema has not changed");
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+import { GraphQLSchema, IntrospectionQuery } from "graphql";
+type LoadResult = {
+    schema: IntrospectionQuery;
+    rawSchema: GraphQLSchema;
+    hasChanged: boolean;
+};
+export declare class GraphQLSchemaLoader {
+    url: string;
+    lastHash: string;
+    constructor(url: string);
+    private cachedResult;
+    get(forceReload?: boolean): Promise<Error | LoadResult>;
+    load(): Promise<Error | LoadResult>;
+    private hashSchema;
+    private processSchema;
+}
+export {};

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

@@ -0,0 +1,94 @@
+import { loadSchema } from "@graphql-tools/load";
+import { UrlLoader } from "@graphql-tools/url-loader";
+import { introspectionFromSchema } from "graphql";
+import { Agent } from "https";
+import fetch from "node-fetch";
+import { graphqlLog as console } from "./graphql-codegen.js";
+import chalk from "chalk";
+import { hash } from "object-code";
+export class GraphQLSchemaLoader {
+    url;
+    lastHash = "";
+    constructor(url) {
+        this.url = url;
+    }
+    cachedResult = null;
+    async get(forceReload = false) {
+        if (forceReload || !this.cachedResult) {
+            return this.load();
+        }
+        return this.cachedResult;
+    }
+    async load() {
+        console.info(`${this.lastHash ? "Reloading" : "Loading"} GraphQL schema from ${chalk.yellowBright(this.url)}`);
+        const rawSchema = await loadSchema(this.url, {
+            loaders: [new UrlLoader()],
+            fetch: (url, opts) => {
+                const httpsAgent = new Agent({
+                    rejectUnauthorized: false,
+                });
+                return fetch(url, {
+                    ...opts,
+                    agent: function (_parsedURL) {
+                        if (_parsedURL.protocol == "http:") {
+                            return undefined;
+                        }
+                        else {
+                            return httpsAgent;
+                        }
+                    },
+                });
+            },
+        }).catch((e) => {
+            return e;
+        });
+        if (rawSchema instanceof Error) {
+            return rawSchema;
+        }
+        console.success(`Loaded schema successfully`);
+        let schema = introspectionFromSchema(rawSchema, {
+            descriptions: true,
+            schemaDescription: false,
+            specifiedByUrl: true,
+        });
+        this.processSchema(schema);
+        const hash = this.hashSchema(schema);
+        let hasChanged = hash !== this.lastHash;
+        this.lastHash = hash;
+        this.cachedResult = {
+            hasChanged,
+            rawSchema,
+            schema,
+        };
+        return this.cachedResult;
+    }
+    hashSchema(schema) {
+        return String(hash(schema));
+    }
+    processSchema(schema) {
+        const updateFieldType = (fieldType) => {
+            if (fieldType.kind === "LIST") {
+                if (fieldType.ofType?.kind !== "NON_NULL") {
+                    fieldType.ofType = {
+                        kind: "NON_NULL",
+                        name: null,
+                        ofType: fieldType.ofType,
+                    };
+                }
+            }
+        };
+        const updateType = (type) => {
+            if (typeof type.type === "object" && type.type) {
+                updateFieldType(type.type);
+            }
+            if (type.fields) {
+                for (const field of type.fields) {
+                    updateType(field);
+                }
+            }
+        };
+        for (const type of schema.__schema.types) {
+            updateType(type);
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+type PluginConfig = {
+    folderName: string;
+    rootDir: string;
+    fallbackType: string;
+    globalName: string;
+    getType?: (importedName: string, definition: any) => string;
+    additionalTypes: {
+        [key: string]: string;
+    };
+};
+declare const _default: {
+    plugin: (schema: any, documents: any, config: PluginConfig, info: any) => string;
+};
+export default _default;

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

@@ -0,0 +1,66 @@
+import { globbySync } from "globby";
+import { relative, resolve } from "path";
+import { code } from "ts-poet";
+export default {
+    plugin: (schema, documents, config, info) => {
+        const folder = resolve(config.rootDir, config.folderName);
+        const imports = [];
+        const items = [];
+        const files = globbySync(folder + "/**/*.tsx");
+        const filesFound = {};
+        const additionalTypes = config.additionalTypes || {};
+        const getRelative = (path) => relative(folder, path);
+        const typeForFile = (file, baseType) => {
+            const types = [];
+            if (baseType)
+                types.push(baseType);
+            if (additionalTypes[file]) {
+                types.push(additionalTypes[file]);
+            }
+            if (types.length === 0) {
+                return config.fallbackType || "{}";
+            }
+            else {
+                return types.join(" & ");
+            }
+        };
+        documents.forEach((doc) => {
+            if (!doc.location.startsWith(config.folderName))
+                return;
+            const relative = getRelative(doc.location);
+            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/, "");
+                items.push(`${JSON.stringify(key)}: ${typeForFile(key, typeName)}`);
+            }
+        });
+        for (const file of files) {
+            if (!filesFound[getRelative(file).replace(/\.tsx/, "")]) {
+                const key = getRelative(file).replace(/\.tsx$/, "");
+                items.push(`${JSON.stringify(key)}: ${typeForFile(key, "")}`);
+            }
+        }
+        return code `
+      /**
+       * DO NOT EDIT
+       * This file is automatically generated by eddev
+       * Any changes will be overwritten
+       */
+      import 'eddev/types.app.public'
+      ${imports.length > 0 ? code `import { ${imports.sort().join(", ")} } from "./types.graphql"` : ""}
+
+      declare global {
+        interface ${config.globalName} {
+          ${items.length > 0 ? items.sort().map((item) => code `${item},\n`) : "_none: {}"}
+        }
+      }
+    `.toString({
+            dprintOptions: {
+                quoteProps: "asNeeded",
+            },
+        });
+    },
+};