eddev 0.3.35 → 2.0.0-beta.1

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

@@ -0,0 +1,8 @@
+type PluginConfig = {
+    rootDir: string;
+};
+declare const _default: {
+    plugin: () => void;
+    validate: (schema: any, documents: any, config: PluginConfig, info: any) => void;
+};
+export default _default;

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

@@ -0,0 +1,10 @@
+export default {
+    plugin: () => { },
+    validate: (schema, documents, config, info) => {
+        documents.forEach((doc) => {
+            if (doc.document.definitions.length === 0) {
+                throw new Error(`GraphQL file '${doc.location}' does not contain any uniquely named operations.`);
+            }
+        });
+    },
+};

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

@@ -0,0 +1,8 @@
+type PluginConfig = {
+    folderName: string;
+    rootDir: string;
+};
+declare const _default: {
+    plugin: (schema: any, documents: any, config: PluginConfig, info: any) => string;
+};
+export default _default;

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

@@ -0,0 +1,263 @@
+import { printSourceLocation, visit, } from "graphql";
+import { code, imp } from "ts-poet";
+import { basename } from "path";
+export default {
+    plugin: (schema, documents, config, info) => {
+        const hooks = {};
+        // const importTypes: string[] = []
+        // const importUtils: { [key: string]: boolean } = {}
+        const impType = (name) => imp(name + "@../types.graphql");
+        const createUseQuery = imp("createUseQuery@eddev/hooks");
+        const createUseMutation = imp("createUseMutation@eddev/hooks");
+        const createUseInfiniteQuery = imp("createUseInfiniteQuery@eddev/hooks");
+        documents.forEach((doc) => {
+            const fullFileName = doc.location;
+            const fileName = doc.location.replace(config.rootDir, "");
+            if (doc.document.definitions.length) {
+                let foundQueryOperation = false;
+                doc.document.definitions.forEach((item) => {
+                    // We only care about 'operations'
+                    if (item.kind !== "OperationDefinition" || !item.name)
+                        return;
+                    function throwErrorAtLocation(loc, message) {
+                        let printedSource = "";
+                        if (loc && loc.source) {
+                            loc.source.name = fileName;
+                            printedSource = printSourceLocation(loc.source, {
+                                line: loc.startToken.line,
+                                column: loc.startToken.column,
+                            });
+                        }
+                        let fullMessage = message;
+                        if (printedSource) {
+                            fullMessage += ":\n\n" + printedSource;
+                        }
+                        else {
+                            fullMessage += ` (in ${fileName})`;
+                        }
+                        const err = new Error(fullMessage);
+                        err.name = "QueryError";
+                        throw err;
+                    }
+                    // Ensure only ONE operation per query file
+                    if (foundQueryOperation) {
+                        throwErrorAtLocation(item.loc, "Only one operation is allowed in each queries/*.graphql file");
+                    }
+                    foundQueryOperation = true;
+                    /**
+                     * Determine the 'hook type'
+                     * - 'mutation' if the operation starts with 'mutation' instead of 'query'
+                     * - 'infinite' if the operation contains the word 'infinite'
+                     * - 'normal' otherwise
+                     */
+                    const type = item.operation === "mutation" ? "mutation" : item.name.value.match(/infinite/i) ? "infinite" : "normal";
+                    const name = item.name.value;
+                    const queryId = fileName.replace(/(^queries\/|.graphql$)/gi, "");
+                    const hookName = "use" + name.replace(/^use/i, "").replace(/^[a-z]/, (c) => c.toUpperCase());
+                    const variablesTypeName = item.variableDefinitions?.length
+                        ? type === "mutation"
+                            ? name + "MutationVariables"
+                            : name + "QueryVariables"
+                        : null;
+                    const resultTypeName = name + (type === "mutation" ? "Mutation" : "Query");
+                    // For conventions sake, the name of the operation should start with 'Use'
+                    if (!name.match(/^Use/)) {
+                        throwErrorAtLocation(item.name.loc, `Expected your query name to start with 'Use', but found '${name}'. Did you mean 'Use${name}'`);
+                    }
+                    // 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')`);
+                    }
+                    // Only import variables if the operation has variables
+                    if (variablesTypeName) {
+                        // importTypes.push(variablesTypeName)
+                    }
+                    // importTypes.push(resultTypeName)
+                    if (type === "normal") {
+                        // Just a normal query!
+                        // importUtils["createUseQuery"] = true
+                        hooks[hookName] = code `
+            ${createUseQuery}<${impType(resultTypeName)}, ${variablesTypeName ? impType(variablesTypeName) : "undefined"}>({
+                name: ${JSON.stringify(queryId)}
+              })
+            `;
+                    }
+                    else if (type === "mutation") {
+                        // A triggerable mutation
+                        // importUtils["createUseMutation"] = true
+                        hooks[hookName] = code `
+            ${createUseMutation}<${impType(resultTypeName)}, ${variablesTypeName ? impType(variablesTypeName) : "undefined"}>({
+                name: ${JSON.stringify(queryId)}
+              })
+            `;
+                    }
+                    else if (type === "infinite") {
+                        // Ensure the query has 'limit' and 'cursor' variables
+                        let limitVariableIsValid = false;
+                        let cursorVariableIsValid = false;
+                        let defaultLimit = 0;
+                        item.variableDefinitions?.forEach((item) => {
+                            const { variable, type, loc, defaultValue } = item;
+                            if (variable?.name?.value === "limit") {
+                                // Found 'limit', but make sure it's an Int, and has a default value
+                                if (type.kind === "NamedType" && type.name.value === "Int") {
+                                    if (defaultValue && defaultValue.kind === "IntValue") {
+                                        limitVariableIsValid = true;
+                                        defaultLimit = Number(defaultValue.value);
+                                    }
+                                    else {
+                                        throwErrorAtLocation(loc, `For infinite queries, be sure to give the '$limit' variable a default value!\nFor example: posts($limit: Int = 10, $cursor: String)\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks`);
+                                    }
+                                }
+                                else {
+                                    // @ts-ignore
+                                    const wrongType = type?.name?.value;
+                                    throwErrorAtLocation(loc, `For infinite queries, the '$limit' variable is expected to be an 'Int' type, but you've used '${wrongType}' instead!\nFor example: posts($limit: Int = 10, $cursor: String)\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks`);
+                                }
+                            }
+                            else if (variable.name.value === "cursor") {
+                                // Found 'cursor', but make sure it's a string
+                                if (type.kind === "NamedType") {
+                                    if (type.name.value === "String") {
+                                        cursorVariableIsValid = true;
+                                    }
+                                    else {
+                                        throwErrorAtLocation(loc, `For infinite queries, the required '$cursor' variable must be an optional String.\nFor example: posts($limit: Int = 10, $cursor: String)\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks`);
+                                    }
+                                }
+                            }
+                        });
+                        // Check that both the 'limit' and 'cursor' variables are present!
+                        if (!cursorVariableIsValid || !limitVariableIsValid) {
+                            throwErrorAtLocation(item.loc, `For infinite queries, you must supply and use the '$limit' and '$cursor' variables\nFor example: posts($limit: Int = 10, $cursor: String) ${cursorVariableIsValid} ${limitVariableIsValid}\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks`);
+                        }
+                        // Finally, ensure that pageInfo is queried somewhere
+                        // We actually want the selection path for a whole bunch of fields, so that we can extract pagination info, and the list of data
+                        const pageInfo = {
+                            nodesPath: null,
+                            pageInfoPath: null,
+                            endCursorPath: null,
+                            hasNextPagePath: null,
+                        };
+                        let nodesPaths = [];
+                        // To do this, we use the visitor pattern to find the pageInfo field selection
+                        let lookingAtPageInfo = true;
+                        let lookupPath = [];
+                        let parentNode;
+                        visit(item.selectionSet, {
+                            enter(node, key, parent, path, ancestors) {
+                                if (node.kind === "Field") {
+                                    lookupPath = [...lookupPath, node.name.value];
+                                    if (node.name.value === "pageInfo") {
+                                        parentNode = ancestors[ancestors.length - 2];
+                                        // parentNode = ancestors
+                                        if (pageInfo.pageInfoPath) {
+                                            // Detected multiple pageInfo fields in the query — confusing!
+                                            throwErrorAtLocation(node.loc, `For infinite queries, be sure to only use 'pageInfo' once. Multiple 'pageInfo' fields were selected in your query!`);
+                                        }
+                                        lookingAtPageInfo = true;
+                                        pageInfo.pageInfoPath = lookupPath;
+                                    }
+                                    else if (node.name.value === "nodes") {
+                                        nodesPaths.push(lookupPath);
+                                    }
+                                    else if (lookingAtPageInfo) {
+                                        if (node.name.value === "endCursor") {
+                                            pageInfo.endCursorPath = lookupPath;
+                                        }
+                                        else if (node.name.value === "hasNextPage") {
+                                            pageInfo.hasNextPagePath = lookupPath;
+                                        }
+                                    }
+                                }
+                            },
+                            leave(node, key, parent, path, ancestors) {
+                                if (node.kind === "Field") {
+                                    lookupPath = lookupPath.slice(0, -1);
+                                    if (node.name.value === "pageInfo") {
+                                        lookingAtPageInfo = false;
+                                    }
+                                }
+                            },
+                        });
+                        // Make sure we found pageInfo { endCursor, hasNextPage }
+                        if (!pageInfo.pageInfoPath || !pageInfo.endCursorPath || !pageInfo.hasNextPagePath) {
+                            throwErrorAtLocation(undefined, `For infinite queries, you need to ensure you select the 'pageInfo' field and it's child 'hasNextPage' and 'endCursor' fields\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks`);
+                        }
+                        // Look for a nodes path which shares the same parent as the pageInfo path
+                        const expectedNodesPath = pageInfo.pageInfoPath.slice(0, -1).join(",");
+                        pageInfo.nodesPath = nodesPaths.find((path) => {
+                            const testPath = path.slice(0, -1).join(",");
+                            return testPath === expectedNodesPath;
+                        });
+                        if (!pageInfo.nodesPath || !parentNode) {
+                            throwErrorAtLocation(undefined, `For infinite queries, be sure to select some nodes using the 'nodes' field, adjacent to the 'pageInfo' field which has been selected.\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks`);
+                        }
+                        let firstArgumentIsValid = false;
+                        let afterArgumentIsValid = false;
+                        parentNode?.arguments?.forEach((arg) => {
+                            if (arg.kind === "Argument") {
+                                if (arg.name.value === "first") {
+                                    if (arg.value.kind === "Variable") {
+                                        if (arg.value.name.value === "limit") {
+                                            firstArgumentIsValid = true;
+                                        }
+                                    }
+                                }
+                                if (arg.name.value === "after") {
+                                    if (arg.value.kind === "Variable") {
+                                        if (arg.value.name.value === "cursor") {
+                                            afterArgumentIsValid = true;
+                                        }
+                                    }
+                                }
+                            }
+                        });
+                        if (parentNode && (!firstArgumentIsValid || !afterArgumentIsValid)) {
+                            throwErrorAtLocation(parentNode.loc, `You must use the arguments (first: $limit, after: $cursor) when using infinite queries.\nRead more -> https://eddev.ed.studio/docs/graphql/query-hooks`);
+                        }
+                        // Drill down to the path type
+                        let finalResultTypeName = impType(resultTypeName);
+                        pageInfo.nodesPath.forEach((key) => {
+                            finalResultTypeName = code `Exclude<${finalResultTypeName}[${JSON.stringify(key)}], undefined | null>`;
+                        });
+                        hooks[hookName] = code `
+            ${createUseInfiniteQuery}<${finalResultTypeName}, ${variablesTypeName ? impType(variablesTypeName) : "undefined"}>({
+                name: ${JSON.stringify(queryId)},
+                defaultLimit: ${defaultLimit},
+                paths: ${JSON.stringify(pageInfo)}
+              })
+            `;
+                    }
+                });
+            }
+        });
+        return code `
+      /**
+       * DO NOT EDIT
+       * This file is automatically generated by eddev
+       * Any changes will be overwritten
+       */
+      ${Object.entries(hooks).map(([name, inner]) => code `
+        export const ${name} = ${inner}
+      `)}
+    `.toString();
+        // const utilsToImport = Object.keys(importUtils)
+        // if (!utilsToImport) return `export {}`
+        // const codeBlocks: string[] = []
+        // // Import required utility functions
+        // // if (utilsToImport.length) {
+        // //   codeBlocks.push(`import { ${utilsToImport.join(", ")} } from 'eddev/hooks/queryUtils'`)
+        // // }
+        // // // Import types from types.graphql
+        // // if (importTypes.length) {
+        // //   codeBlocks.push(`import { ${importTypes} } from '../types.graphql'`)
+        // // }
+        // for (const hookName in hooks) {
+        //   const hookCode = hooks[hookName]
+        //   codeBlocks.push(`export const ${hookName} = ${hookCode}`)
+        // }
+        // return codeBlocks.join("\n\n")
+    },
+};

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

@@ -0,0 +1,26 @@
+import { DocumentNode } from "graphql";
+import { Project } from "../project/project.js";
+type Entry = {
+    group: string;
+    path: string;
+    contents: string;
+    ast: DocumentNode;
+    parseError: {
+        message: string;
+        line?: number;
+        column?: number;
+    } | null;
+};
+export type GraphQLManifest<TKeys extends string> = {
+    [K in TKeys]: {
+        [key: string]: Entry;
+    };
+};
+export type GraphQLFileLoader<TKeys extends string> = ReturnType<typeof createGraphQLFileLoader<TKeys>>;
+type PatternMap<TKeys extends string> = {
+    key: TKeys;
+    baseFolder: string;
+    pattern: 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

@@ -0,0 +1,54 @@
+import { parse } from "graphql";
+import { join } from "path";
+import { cliMode } from "../cli/cli-mode.js";
+import { createManifestGenerator } from "../project/manifest/manifest.js";
+import { fs } from "../utils/fs.js";
+export function createGraphQLFileLoader(project, patterns) {
+    return createManifestGenerator({
+        baseDir: project.rootDir,
+        pattern: patterns.map((p) => join(p.baseFolder, p.pattern)),
+        watch: cliMode.watch,
+        async generateManifest(entries) {
+            let result = {};
+            patterns.forEach((p) => {
+                result[p.key] = {};
+            });
+            Object.entries(entries).forEach(([_, { value }]) => {
+                result[value.group][value.path] = value;
+            });
+            return result;
+        },
+        getKey(path) {
+            return path;
+        },
+        async loadValue(path, key) {
+            let group = "";
+            for (let pattern of patterns) {
+                if (path.startsWith(pattern.baseFolder)) {
+                    group = pattern.key;
+                    break;
+                }
+            }
+            const contents = await fs.readFile(path, "utf8");
+            let ast = null;
+            let parseError = null;
+            try {
+                ast = parse(contents);
+            }
+            catch (err) {
+                parseError = {
+                    message: err.message,
+                    line: err.locations[0].line,
+                    column: err.locations[0].column,
+                };
+            }
+            return {
+                group,
+                path,
+                contents,
+                ast,
+                parseError,
+            };
+        },
+    });
+}

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

@@ -0,0 +1 @@
+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";

package/dist/node/graphql/wp-info-query.js

@@ -0,0 +1,29 @@
+export const WPInfoQuery = `
+  query WPInfo {
+    contentTypes(first: 100) {
+      nodes {
+        name
+        label
+        hasArchive
+        graphqlSingleName
+        graphqlPluralName
+        excludeFromSearch
+      }
+    }
+    taxonomies(first: 100) {
+      nodes {
+        graphqlPluralName
+        graphqlSingleName
+        name
+        label
+      }
+    }
+    plugins(first: 100) {
+      nodes {
+        name
+        pluginUri
+        version
+      }
+    }
+  }
+`;

package/{config/config-schema.d.ts → dist/node/project/config.d.ts}

@@ -1,6 +1,10 @@
 import { z } from "zod";
+import { Project } from "./project.js";
 export declare const EDConfigSchema: z.ZodObject<{
     $schema: z.ZodOptional<z.ZodString>;
+    version: z.ZodEffects<z.ZodEnum<["1", "2"]>, "2", "1" | "2">;
+    legacyMetadata: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    legacyStitches: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     tracking: z.ZodOptional<z.ZodObject<{
         tagManagerID: z.ZodOptional<z.ZodString>;
         ga: z.ZodOptional<z.ZodObject<{
@@ -26,13 +30,12 @@ export declare const EDConfigSchema: z.ZodObject<{
             trackingID?: string | undefined;
         } | undefined;
     }>>;
-    serverless: z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodBoolean;
+    serverless: z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
         uploads: z.ZodEnum<["proxy", "remote"]>;
-        plugins: z.ZodEnum<["proxy", "remote"]>;
-        theme: z.ZodEnum<["proxy", "copy", "remote"]>;
-        themeAssets: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        apiOnly: z.ZodOptional<z.ZodBoolean>;
+        plugins: z.ZodDefault<z.ZodEnum<["proxy", "remote"]>>;
+        themeAssets: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        apiOnly: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         endpoints: z.ZodRecord<z.ZodString, z.ZodString>;
         defaultRevalidate: z.ZodOptional<z.ZodNumber>;
         defaultRevalidateQueries: z.ZodOptional<z.ZodNumber>;
@@ -40,23 +43,21 @@ export declare const EDConfigSchema: z.ZodObject<{
         enabled: boolean;
         uploads: "proxy" | "remote";
         plugins: "proxy" | "remote";
-        theme: "copy" | "proxy" | "remote";
+        themeAssets: string[];
+        apiOnly: boolean;
         endpoints: Record<string, string>;
-        themeAssets?: string[] | undefined;
-        apiOnly?: boolean | undefined;
         defaultRevalidate?: number | undefined;
         defaultRevalidateQueries?: number | undefined;
     }, {
-        enabled: boolean;
         uploads: "proxy" | "remote";
-        plugins: "proxy" | "remote";
-        theme: "copy" | "proxy" | "remote";
         endpoints: Record<string, string>;
+        enabled?: boolean | undefined;
+        plugins?: "proxy" | "remote" | undefined;
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
         defaultRevalidate?: number | undefined;
         defaultRevalidateQueries?: number | undefined;
-    }>>;
+    }>;
     cache: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         props: z.ZodNumber;
         queries: z.ZodNumber;
@@ -67,9 +68,22 @@ export declare const EDConfigSchema: z.ZodObject<{
         props: number;
         queries: number;
     }>>>;
-    devUI: z.ZodEnum<["disabled", "enabled"]>;
+    devUI: z.ZodDefault<z.ZodEnum<["disabled", "enabled"]>>;
 }, "strip", z.ZodTypeAny, {
-    devUI: "disabled" | "enabled";
+    version: "2";
+    legacyMetadata: boolean;
+    legacyStitches: boolean;
+    serverless: {
+        enabled: boolean;
+        uploads: "proxy" | "remote";
+        plugins: "proxy" | "remote";
+        themeAssets: string[];
+        apiOnly: boolean;
+        endpoints: Record<string, string>;
+        defaultRevalidate?: number | undefined;
+        defaultRevalidateQueries?: number | undefined;
+    };
+    devUI: "enabled" | "disabled";
     $schema?: string | undefined;
     tracking?: {
         tagManagerID?: string | undefined;
@@ -78,24 +92,25 @@ export declare const EDConfigSchema: z.ZodObject<{
             trackingID?: string | undefined;
         } | undefined;
     } | undefined;
-    serverless?: {
-        enabled: boolean;
+    cache?: Record<string, {
+        props: number;
+        queries: number;
+    }> | undefined;
+}, {
+    version: "1" | "2";
+    serverless: {
         uploads: "proxy" | "remote";
-        plugins: "proxy" | "remote";
-        theme: "copy" | "proxy" | "remote";
         endpoints: Record<string, string>;
+        enabled?: boolean | undefined;
+        plugins?: "proxy" | "remote" | undefined;
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
         defaultRevalidate?: number | undefined;
         defaultRevalidateQueries?: number | undefined;
-    } | undefined;
-    cache?: Record<string, {
-        props: number;
-        queries: number;
-    }> | undefined;
-}, {
-    devUI: "disabled" | "enabled";
+    };
     $schema?: string | undefined;
+    legacyMetadata?: boolean | undefined;
+    legacyStitches?: boolean | undefined;
     tracking?: {
         tagManagerID?: string | undefined;
         ga?: {
@@ -103,20 +118,21 @@ export declare const EDConfigSchema: z.ZodObject<{
             trackingID?: string | undefined;
         } | undefined;
     } | undefined;
-    serverless?: {
-        enabled: boolean;
-        uploads: "proxy" | "remote";
-        plugins: "proxy" | "remote";
-        theme: "copy" | "proxy" | "remote";
-        endpoints: Record<string, string>;
-        themeAssets?: string[] | undefined;
-        apiOnly?: boolean | undefined;
-        defaultRevalidate?: number | undefined;
-        defaultRevalidateQueries?: number | undefined;
-    } | undefined;
     cache?: Record<string, {
         props: number;
         queries: number;
     }> | undefined;
+    devUI?: "enabled" | "disabled" | undefined;
 }>;
-export declare type EDConfig = z.infer<typeof EDConfigSchema>;
+export type EDConfig = z.infer<typeof EDConfigSchema>;
+export declare class Configurator {
+    project: Project;
+    config?: EDConfig;
+    private constructor();
+    static create(project: Project): Promise<Configurator>;
+    load(): Promise<void>;
+    private ensureConfigSchema;
+    private loadConfig;
+    private reportError;
+    static describeConfig(config: EDConfig, project: Project): string;
+}