eddev 0.3.38 → 2.0.0-beta.10

package/dist/node/project/config.js

@@ -0,0 +1,138 @@
+import { objFormat } from "obj-console";
+import path from "path";
+import { z } from "zod";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { cliMode } from "../cli/cli-mode.js";
+import { fs } from "../utils/fs.js";
+import { isDeploying } from "../utils/is-deploying.js";
+import { projectLog as console } from "./project.js";
+export const EDConfigSchema = z.object({
+    $schema: z.string().optional(),
+    version: z.enum(["1", "2"]).refine((v) => v === "2", { message: "Only version 2 is supported" }),
+    legacyMetadata: z
+        .boolean()
+        .optional()
+        .default(false)
+        .describe("Whether to use legacy comments or exported JSON for block and view metadata"),
+    legacyStitches: z.boolean().optional().default(true).describe("Whether this site is using Stitches"),
+    tracking: z
+        .object({
+        tagManagerID: z.string().optional(),
+        ga: z
+            .object({
+            trackingID: z.string().optional(),
+            version: z.enum(["3", "4"]),
+        })
+            .optional(),
+    })
+        .optional(),
+    serverless: z.object({
+        enabled: z.boolean().default(true).describe("Whether to deploy the site as a serverless app"),
+        uploads: z
+            .enum(["proxy", "remote"])
+            .describe("Whether to proxy plugin assets or serve them from the serverless endpoint.\nDefault is `remote`, but `proxy` can be used to hide the CMS origin, but may incur additional bandwidth costs."),
+        plugins: z
+            .enum(["proxy", "remote"])
+            .default("remote")
+            .describe("Whether to proxy plugin assets or serve them from the serverless endpoint.\nDefault is `remote`, but `proxy` can be used to hide the CMS origin."),
+        // theme: z.enum(["proxy", "copy", "remote"]),
+        themeAssets: z
+            .array(z.string())
+            .optional()
+            .default(["assets"])
+            .describe('Files to include in a serverless deployment.\nDefault is `["assets"]`'),
+        apiOnly: z.boolean().optional().default(false).describe("Whether to deploy only the API, not the frontend"),
+        endpoints: z
+            .record(z.string(), z.string())
+            .describe("A map of WordPress hostnames -> serverless hostnames. You can use `*` as a wildcard for the key.\n\nFor example, `{'cms.ed.studio': 'ed.studio'}` tells the WordPress frontend where it can find any serverless API endpoints."),
+        defaultRevalidate: z.number().optional(),
+        defaultRevalidateQueries: z.number().optional(),
+    }),
+    cache: z
+        .record(z.string(), z.object({
+        props: z.number(),
+        queries: z.number(),
+    }))
+        .optional(),
+    devUI: z.enum(["disabled", "enabled"]).default("enabled"),
+});
+export class Configurator {
+    project;
+    config;
+    constructor(project) {
+        this.project = project;
+    }
+    static async create(project) {
+        const config = new Configurator(project);
+        await config.load();
+        return config;
+    }
+    async load() {
+        console.verbose("Booting up configurator...");
+        if (!cliMode.readonly) {
+            await this.ensureConfigSchema();
+        }
+        this.config = await this.loadConfig(cliMode.exitOnValidationError);
+    }
+    async ensureConfigSchema() {
+        if (isDeploying())
+            return;
+        console.verbose("Ensuring config schema exists...");
+        const schemaPath = path.resolve(this.project.rootDir, ".ed.config.schema.json");
+        const didChange = await fs.writeJsonIfUnchanged(schemaPath, zodToJsonSchema(EDConfigSchema)).catch((err) => {
+            console.error("Failed to write config schema file:\n", err);
+        });
+        if (didChange) {
+            console.verbose("Updated config schema");
+        }
+    }
+    async loadConfig(exitOnError) {
+        let loaded = await fs.readJson(this.project.configFile).catch((err) => {
+            console.error("Failed to read config file:\n");
+            throw err;
+        });
+        console.verbose("Raw Config:\n", loaded);
+        const result = EDConfigSchema.safeParse(loaded);
+        if (result.success) {
+            console.verbose("Config parsed successfully:\n", result.data);
+            if (cliMode.detailed) {
+                if (!result.data) {
+                    console.fail("Config could not be loaded");
+                    return;
+                }
+                else {
+                    console.startGroup("Config:");
+                    console.success("Loaded ed.config.json successfully");
+                    console.log(Configurator.describeConfig(result.data, this.project));
+                    console.endGroup();
+                }
+            }
+            delete result.data.$schema;
+            return result.data;
+        }
+        else {
+            this.reportError(result.error);
+            this.config = undefined;
+            if (exitOnError) {
+                console.flush();
+                process.exit(0);
+            }
+        }
+    }
+    reportError(error) {
+        console.startGroup(`Validation failed for '${this.project.configFile}'`, "error");
+        console.zodError(error);
+        console.help(`Please open '${this.project.configFile}' and look for the validation errors.`);
+        console.endGroup();
+    }
+    static describeConfig(config, project) {
+        // TODO: Make this human-readable!
+        return objFormat(config, {
+            unfoldDepth: 2,
+            omitBrackets: true,
+            quote: "",
+            omitEolCommas: true,
+            padding: " ",
+        });
+    }
+}

package/dist/node/project/eddev-build-file.d.ts

@@ -0,0 +1,10 @@
+import type { Project } from "./project.js";
+/**
+ * This class writes theme info to the theme-manifest.json file, which is then consumed by PHP code.
+ */
+export declare class BuildInfoWriter {
+    project: Project;
+    constructor(project: Project);
+    watch(): void;
+    write(): Promise<void>;
+}

package/dist/node/project/eddev-build-file.js

@@ -0,0 +1,79 @@
+import { join } from "path";
+import { fs } from "../utils/fs.js";
+import { kebabCase, snakeCase } from "change-case-all";
+/**
+ * This class writes theme info to the theme-manifest.json file, which is then consumed by PHP code.
+ */
+export class BuildInfoWriter {
+    project;
+    constructor(project) {
+        this.project = project;
+    }
+    watch() {
+        this.project.blocks.subscribeFuture((blocks) => {
+            this.write();
+        });
+        this.project.views.subscribeFuture((blocks) => {
+            this.write();
+        });
+    }
+    async write() {
+        const [blockManifest, viewManifest] = await Promise.all([this.project.blocks.get(), this.project.views.get()]);
+        const toAcfBlockName = (name) => {
+            if (blockManifest.blocks[name]?.acfName) {
+                return blockManifest.blocks[name].acfName;
+            }
+            return name;
+        };
+        const data = {
+            blocks: Object.values(blockManifest.blocks)
+                .sort((a, b) => b.fileName.localeCompare(a.fileName))
+                .map((block) => {
+                // See https://github.com/WordPress/wordpress-develop/blob/6.4/src/wp-includes/class-wp-block-type.php#L18-L541
+                return {
+                    id: block.slug,
+                    acfName: block.acfName,
+                    graphqlFieldName: snakeCase(block.slug.replace("/", "-")),
+                    name: kebabCase(block.slug.replace("/", "-")),
+                    title: block.title,
+                    category: block.category,
+                    types: block.types,
+                    templates: block.templates,
+                    parent: block.parent?.length > 0 ? block.parent.map(toAcfBlockName) : [],
+                    ancestor: block.ancestors?.length > 0 ? block.ancestors.map(toAcfBlockName) : undefined,
+                    icon: block.icon ? kebabCase(block.icon) : undefined,
+                    description: block.description,
+                    keywords: block.keywords,
+                    tags: block.tags,
+                    flags: block.flags,
+                    childTags: block.childTags?.length ? block.childTags : undefined,
+                    allowed_blocks: block.childBlocks?.length ? block.childBlocks.map(toAcfBlockName) : undefined,
+                    supports: {
+                        align: false,
+                        align_text: false,
+                        align_center: false,
+                        multiple: block.allowMultiple ? true : false,
+                        mode: block.mode ?? "preview",
+                        customClassName: false,
+                        inserter: block.inserter,
+                    },
+                    mode: block.mode ?? "preview",
+                    canCache: block.cache,
+                    frontendMode: block.frontendMode,
+                    postmeta: block.postMetaBlock,
+                };
+            }),
+            templates: Object.values(viewManifest.views)
+                .filter((view) => view.isCustomTemplate)
+                .map((view) => {
+                return {
+                    postType: view.postType,
+                    fileName: view.fileName,
+                    cache: view.cache,
+                    title: view.title,
+                };
+            }),
+        };
+        fs.writeJsonIfUnchanged(join(this.project.rootDir, "ed.dist.json"), data);
+    }
+}

package/dist/node/project/env.d.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export type ProjectEnvMap = z.infer<typeof ProjectEnvSchema>;
+export declare const fields: {
+    readonly DEBUG_GRAPHQL_URL: z.ZodString;
+    readonly SITE_URL: z.ZodString;
+    readonly DEV_HOT_PORT: z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>;
+    readonly DEV_SERVERLESS_PORT: z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>;
+};
+export declare const ProjectEnvSchema: z.ZodObject<{
+    readonly DEBUG_GRAPHQL_URL: z.ZodOptional<z.ZodString>;
+    readonly SITE_URL: z.ZodOptional<z.ZodString>;
+    readonly DEV_HOT_PORT: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>>;
+    readonly DEV_SERVERLESS_PORT: z.ZodOptional<z.ZodEffects<z.ZodEffects<z.ZodDefault<z.ZodString>, string | number, string | undefined>, number, string | undefined>>;
+}, "strip", z.ZodTypeAny, {
+    DEBUG_GRAPHQL_URL?: string | undefined;
+    SITE_URL?: string | undefined;
+    DEV_HOT_PORT?: number | undefined;
+    DEV_SERVERLESS_PORT?: number | undefined;
+}, {
+    DEBUG_GRAPHQL_URL?: string | undefined;
+    SITE_URL?: string | undefined;
+    DEV_HOT_PORT?: string | undefined;
+    DEV_SERVERLESS_PORT?: string | undefined;
+}>;
+export type ProjectEnvKey = keyof typeof fields;
+export declare const ProjectEnvUtils: {
+    /**
+     * Ensure environment variables are in the correct syntax
+     * All environment variables are optional
+     */
+    parse(exitOnFail: boolean): {
+        valid: true;
+        env: ProjectEnvMap;
+    } | {
+        valid: false;
+    };
+    getSafe<T extends ProjectEnvKey>(key: T): Required<ProjectEnvMap[T]> | undefined;
+    get<T extends ProjectEnvKey>(key: T, cons?: import("../utils/stateful-log.js").StatefulLog<import("./project.js").Project>): z.infer<(typeof fields)[T]>;
+};

package/dist/node/project/env.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { cliMode } from "../cli/cli-mode.js";
+import { projectLog as console } from "./project.js";
+import { formatZodError } from "../utils/format-zod-error.js";
+const portNumber = z
+    .string()
+    .default("0")
+    .transform((val) => (val === "0" ? Math.floor(8000 + Math.random() * 1000) : val))
+    .transform((val) => (typeof val === "string" ? parseInt(val) : val));
+export const fields = {
+    DEBUG_GRAPHQL_URL: z
+        .string()
+        .url()
+        .describe("The GraphQL endpoint served by GraphQL, needed for Typescript code generation. It should be automatically set when running running WordPress with the stack configured correctly. If this is a new site, you may need to refresh the admin panel."),
+    SITE_URL: z.string().url().describe("The URL of the site"),
+    DEV_HOT_PORT: portNumber,
+    DEV_SERVERLESS_PORT: portNumber,
+};
+export const ProjectEnvSchema = z.object(fields).partial();
+export const ProjectEnvUtils = {
+    /**
+     * Ensure environment variables are in the correct syntax
+     * All environment variables are optional
+     */
+    parse(exitOnFail) {
+        const result = ProjectEnvSchema.safeParse(process.env);
+        if (result.success) {
+            if (cliMode.verbose) {
+                console.success("No formatting issues with provided environment variables");
+            }
+            for (let k in result.data) {
+                process.env[k] = result.data[k];
+            }
+            return {
+                valid: true,
+                env: result.data,
+            };
+        }
+        else {
+            const error = result.error;
+            if (error) {
+                console.error("Failed to validate some environment variables variables:\n", error);
+            }
+            if (exitOnFail) {
+                console.flush();
+                process.exit(1);
+            }
+            return {
+                valid: false,
+            };
+        }
+    },
+    getSafe(key) {
+        const result = fields[key].safeParse(process.env[key]);
+        if (result.success) {
+            return result.data;
+        }
+        else {
+            return undefined;
+        }
+    },
+    get(key, cons = console) {
+        const schema = fields[key];
+        const result = schema.safeParse(process.env[key]);
+        if (result.success) {
+            return result.data;
+        }
+        else {
+            cons.error(`Missing or invalid environment variable:\n"${key}"\n${formatZodError(result.error)}`);
+            if (schema.description) {
+                cons.info(`About "${key}":\n` + schema.description + "\n");
+            }
+            cons.flush();
+            process.exit(1);
+        }
+    },
+};

package/dist/node/project/favicons.js

@@ -0,0 +1 @@
+"use strict";

package/dist/node/project/manifest/block-manifest.d.ts

@@ -0,0 +1,19 @@
+import { BlockMetadata, BlockMetadataConstructor } from "../../types/block-type.js";
+import { Project } from "../project.js";
+export type BlockManifest = {
+    blocks: {
+        [K: string]: BlockMetadata;
+    };
+    validationMessages: {
+        blockKey: string;
+        message: string;
+        severity: "error" | "warning";
+    }[];
+};
+type BlockLoadResult = {
+    data: BlockMetadataConstructor | null;
+    error?: string;
+};
+export type BlockManifestGenerator = ReturnType<typeof loadBlockManifest>;
+export declare function loadBlockManifest(project: Project): import("./manifest.js").ManifestGenerator<BlockLoadResult, BlockManifest>;
+export {};

package/dist/node/project/manifest/block-manifest.js

@@ -0,0 +1,206 @@
+import { camelCase, kebabCase } from "change-case-all";
+import { cliMode } from "../../cli/cli-mode.js";
+import { BlockMetaSchema } from "../../types/block-type.js";
+import { metaExtractor } from "../../utils/ts-export-extractor.js";
+import { formatZodError } from "../../utils/format-zod-error.js";
+import { fs } from "../../utils/fs.js";
+import { createManifestGenerator } from "./manifest.js";
+export function loadBlockManifest(project) {
+    return createManifestGenerator({
+        baseDir: project.rootDir,
+        pattern: "blocks/**/*.tsx",
+        watch: cliMode.watch,
+        async generateManifest(entries) {
+            let result = {
+                blocks: {},
+                validationMessages: [],
+            };
+            Object.entries(entries)
+                .sort(([b1], [b2]) => {
+                return b1.localeCompare(b2);
+            })
+                .forEach(([key, entry]) => {
+                const { data, error: initialError } = entry.value;
+                // Add the block to the manifest, even though it might be broken.
+                // Any broken blocks will have warnings/errors attached.
+                result.blocks[key] = data;
+                // If there was an error loading the block, add it to the manifest
+                if (initialError) {
+                    result.validationMessages.push({
+                        blockKey: key,
+                        message: initialError,
+                        severity: "error",
+                    });
+                    return;
+                }
+                else {
+                    // Validate the structure of the metadata
+                    const parsed = BlockMetaSchema.safeParse(data);
+                    if (parsed.success) {
+                        // The block metadata matches our schema, and may have been transformed
+                        result.blocks[key] = parsed.data;
+                    }
+                    else {
+                        result.validationMessages.push({
+                            blockKey: key,
+                            message: "Metadata validation error:\n" + formatZodError(parsed.error),
+                            severity: "warning",
+                        });
+                    }
+                }
+            });
+            return result;
+        },
+        getKey(path) {
+            // Ignore files which start with an underscore
+            if (path.startsWith("_core"))
+                return null;
+            // Strip the blocks folder name + extension
+            return path.replace(/\.tsx$/, "").replace(/^blocks\//, "");
+        },
+        onFileChange(path) {
+            metaExtractor.invalidate(path);
+        },
+        async loadValue(path, key) {
+            const contents = await fs.readFile(path, "utf8");
+            // Start with a default value
+            let metadata = {
+                acfName: `acf/${key.toLowerCase().replace(/\//g, "-").replace("_", "")}`,
+                fileName: path,
+                slug: key,
+                graphqlFieldName: key
+                    .split("/")
+                    .map((s) => camelCase(s))
+                    .join("_"),
+                title: key,
+                types: [],
+            };
+            let result;
+            /**
+             * If the project is configured to use legacy metadata, read the metadata from
+             * the comment header.
+             *
+             * Otherwise, we'll pull it as JSON straight from the .tsx file
+             */
+            if (project.config?.legacyMetadata) {
+                result = readBlockDataAsComment(contents);
+                if (!result) {
+                    return {
+                        data: metadata,
+                        error: `Could not read block metadata from comment header`,
+                    };
+                }
+            }
+            else {
+                result = readBlockDataAsJSONExport(path, contents);
+                if (!result) {
+                    return {
+                        data: metadata,
+                        error: "Could not find `export const meta` in file, or it was not statically parsable.",
+                    };
+                }
+            }
+            Object.assign(metadata, result);
+            // Compute the various names for this block
+            return {
+                data: metadata,
+            };
+        },
+    });
+}
+/**
+ * Rip the JSON metadata directly from the .tsx file
+ */
+function readBlockDataAsJSONExport(file, contents) {
+    const userData = metaExtractor.extract(file, contents);
+    if (!userData)
+        return null;
+    const result = {};
+    result.title = userData.title;
+    result.description = userData.description;
+    result.category = userData.category;
+    result.icon = userData.icon ? kebabCase(userData.icon) : undefined;
+    result.cache = userData.cache;
+    result.tags = userData.tags;
+    result.flags = userData.flags;
+    // result.childTags = userData.innerBlocks?.allowedTags
+    // result.childBlocks = userData.innerBlocks?.allowedBlocks
+    result.ancestors = userData.conditions?.parents;
+    result.parent = userData.conditions?.parents;
+    result.types = userData.conditions?.postTypes;
+    result.templates = userData.conditions?.templates;
+    result.allowMultiple = userData.conditions?.multiple !== false;
+    result.inserter = userData.inserter;
+    result.frontendMode = userData.frontendMode;
+    if (userData.postMetaBlock) {
+        result.postMetaBlock = {
+            fieldName: userData.postMetaBlock.fieldName,
+        };
+        result.types = userData.postMetaBlock.postTypes;
+        result.allowMultiple = false;
+    }
+    return result;
+}
+/**
+ * Parse as a legacy comment header
+ */
+function readBlockDataAsComment(file) {
+    let meta = {};
+    // Ensure the comment header is set
+    if (!/^\/\*.+?\*\//s.test(file))
+        return null;
+    // Get the comment section
+    const commentSection = file.match(/^.+\*\//s);
+    if (!commentSection)
+        return null;
+    const lines = commentSection[0].split("\n");
+    lines.forEach((line, i) => {
+        const match = line.match(/\s*\*?\s*([^:]+):\s*(.+)\s*/);
+        if (!match)
+            return;
+        let key = match[1].replace(/\s/g, "").toLocaleLowerCase();
+        let value = match[2].trim();
+        switch (key) {
+            case "title":
+                meta.title = value;
+                return;
+            case "description":
+                meta.description = value;
+                return;
+            case "category":
+                meta.category = value;
+                return;
+            case "icon":
+                meta.icon = value ? kebabCase(value) : "";
+                return;
+            case "keywords":
+                meta.keywords = value.split(/,\s*/);
+                return;
+            case "types":
+                meta.types = value.split(/,\s*/);
+                return;
+            case "templates":
+                meta.templates = value.split(/,\s*/);
+                return;
+            case "mode":
+                meta.mode = value;
+                return;
+            case "tags":
+                meta.tags = value.split(/,\s*/);
+                return;
+            case "childTags":
+                meta.childTags = value.split(/,\s*/);
+                return;
+            case "dynamic":
+                meta.dynamic = value === "true";
+                return;
+            case "cache":
+                meta.cache = value === "true";
+                return;
+            case "supportsmultiple":
+                meta.allowMultiple = value === "true";
+                return;
+        }
+    });
+    return meta;
+}

package/dist/node/project/manifest/field-manifest.d.ts

@@ -0,0 +1,17 @@
+import { Project } from "../project.js";
+export type FieldManifest = {
+    fields: Record<string, FieldInfo>;
+    validationMessages: {
+        fieldKey: string;
+        message: string;
+        severity: "error" | "warning";
+    }[];
+};
+type FieldInfo = {
+    fileName: string;
+    slug: string;
+    error?: string;
+};
+export type FieldManifestGenerator = ReturnType<typeof loadFieldManifest>;
+export declare function loadFieldManifest(project: Project): import("./manifest.js").ManifestGenerator<FieldInfo, FieldManifest>;
+export {};

package/dist/node/project/manifest/field-manifest.js

@@ -0,0 +1,42 @@
+import { cliMode } from "../../cli/cli-mode.js";
+import { createManifestGenerator } from "./manifest.js";
+export function loadFieldManifest(project) {
+    return createManifestGenerator({
+        baseDir: project.rootDir,
+        pattern: "backend/fields/*.tsx",
+        watch: cliMode.watch,
+        async generateManifest(entries) {
+            let result = {
+                fields: {},
+                validationMessages: [],
+            };
+            Object.entries(entries)
+                .sort(([b1], [b2]) => {
+                return b1.localeCompare(b2);
+            })
+                .forEach(([key, entry]) => {
+                const { error: initialError } = entry.value;
+                result.fields[key] = entry.value;
+                if (initialError) {
+                    result.validationMessages.push({
+                        fieldKey: key,
+                        message: initialError,
+                        severity: "error",
+                    });
+                    return;
+                }
+            });
+            return result;
+        },
+        getKey(path) {
+            // Strip the views folder name + extension
+            return path.replace(/\.tsx$/, "").replace(/^backend\/fields\//, "");
+        },
+        async loadValue(fileName, key) {
+            return {
+                slug: key,
+                fileName,
+            };
+        },
+    });
+}

package/dist/node/project/manifest/manifest.d.ts

@@ -0,0 +1,30 @@
+import { FileEvent } from "../../utils/watch-file-tree.js";
+type ManifestEntry<TEntryData> = {
+    key: string;
+    relativePath: string;
+    fullPath: string;
+    value: TEntryData;
+};
+type ManifestGeneratorArgs<TEntryData, TManifest> = {
+    baseDir: string;
+    pattern: string | string[];
+    watch: boolean;
+    loadValue: (path: string, key: string) => Promise<TEntryData>;
+    getKey: (path: string) => string | null;
+    generateManifest: (entries: {
+        [key: string]: ManifestEntry<TEntryData>;
+    }) => Promise<TManifest>;
+    onFileChange?(path: string): void;
+};
+export type ManifestGenerator<TEntryData, TManifest> = {
+    /** Destroy the generator, and stop watching for changes */
+    dispose: () => void;
+    /** Subscribe to changes, and also kick off the monitor process if it hasn't already started */
+    subscribe: (callback: (manifest: TManifest, events?: FileEvent[]) => void) => () => void;
+    /** Subscribe to future changes */
+    subscribeFuture: (callback: (manifest: TManifest, events?: FileEvent[]) => void) => () => void;
+    /** Get the existing manifest, or generate a new one if one hasn'tyet been created */
+    get(): Promise<TManifest>;
+};
+export declare function createManifestGenerator<TEntryData, TManifest>(args: ManifestGeneratorArgs<TEntryData, TManifest>): ManifestGenerator<TEntryData, TManifest>;
+export {};