eddev 2.0.0-beta.1 → 2.0.0-beta.100

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

@@ -1,9 +1,10 @@
 import { EDConfig } from "./config.js";
 import { BlockManifestGenerator } from "./manifest/block-manifest.js";
-import { ViewManifestGenerator } from "./manifest/view-manifest.js";
 import { FieldManifestGenerator } from "./manifest/field-manifest.js";
+import { RouteManifestGenerator } from "./manifest/routes-manifest.js";
+import { ViewManifestGenerator } from "./manifest/view-manifest.js";
 import { WidgetManifestGenerator } from "./manifest/widget-manifest.js";
-export declare const projectLog: import("../utils/statefulLog.js").StatefulLog<Project>;
+export declare const projectLog: import("../utils/stateful-log.js").StatefulLog<Project>;
 type ProjectArgs = {
     rootDir: string;
     reportPluginCompatibility?: boolean;
@@ -18,14 +19,22 @@ export declare class Project {
     publicUrl: string;
     repoUrl: string;
     configFile: string;
+    origin: string;
     config?: EDConfig;
     blocks: BlockManifestGenerator;
     views: ViewManifestGenerator;
     fields: FieldManifestGenerator;
     widgets: WidgetManifestGenerator;
+    serverRoutes: RouteManifestGenerator;
     private wp;
     reportPluginCompatibility: boolean;
     private constructor();
+    verifyOriginAccess(): Promise<{
+        success: true;
+    } | {
+        success: false;
+        message: string;
+    }>;
     private load;
     reportProjectInfo(): string;
     getWordpressInfo(): Promise<{

package/dist/node/project/project.js

@@ -1,19 +1,17 @@
-import * as clack from "@clack/prompts";
+import { objFormat } from "obj-console";
 import { relative, resolve } from "path";
 import { undent } from "undent";
-import { cliMode } from "../cli/cli-mode.js";
-// import { console } from "../utils/console.js"
-import { objFormat } from "obj-console";
-import { getRepoInfo } from "../utils/getRepoInfo.js";
-import { isDeploying } from "../utils/isDeploying.js";
-import { createConsole } from "../utils/statefulLog.js";
+import { getRepoInfo } from "../utils/get-repo-info.js";
+import { isDeploying } from "../utils/is-deploying.js";
+import { createConsole } from "../utils/stateful-log.js";
 import { Configurator } from "./config.js";
-import { loadBlockManifest } from "./manifest/block-manifest.js";
-import { loadViewManifest } from "./manifest/view-manifest.js";
-import { WPInfo } from "./wp-info.js";
 import { ProjectEnvUtils } from "./env.js";
+import { loadBlockManifest } from "./manifest/block-manifest.js";
 import { loadFieldManifest } from "./manifest/field-manifest.js";
+import { loadRouteManifest } from "./manifest/routes-manifest.js";
+import { loadViewManifest } from "./manifest/view-manifest.js";
 import { loadWidgetManifest } from "./manifest/widget-manifest.js";
+import { WPInfo } from "./wp-info.js";
 const console = createConsole("Project", "project");
 export const projectLog = console;
 /**
@@ -26,21 +24,53 @@ export class Project {
     publicUrl = "";
     repoUrl = "";
     configFile = "";
+    origin = "";
     config;
     blocks;
     views;
     fields;
     widgets;
+    serverRoutes;
     wp;
     reportPluginCompatibility = false;
     constructor(opts) {
         this.rootDir = opts.rootDir;
+        this.origin = ProjectEnvUtils.getSafe("SITE_URL") ?? "";
         this.reportPluginCompatibility = opts.reportPluginCompatibility || false;
         this.blocks = loadBlockManifest(this);
         this.views = loadViewManifest(this);
         this.fields = loadFieldManifest(this);
         this.widgets = loadWidgetManifest(this);
-        this.wp = new WPInfo(ProjectEnvUtils.get("SITE_URL"));
+        this.serverRoutes = loadRouteManifest(this);
+        this.wp = new WPInfo(this.origin);
+    }
+    async verifyOriginAccess() {
+        try {
+            const response = await this.wp.ping();
+            if (!response.ok) {
+                return {
+                    success: false,
+                    message: [
+                        `Failed to access WordPress origin at ${this.origin}`,
+                        `Using API Key?: ${ProjectEnvUtils.getSafe("SITE_API_KEY") ? "Yes" : "No"}`,
+                        `Response: ${response.status} ${response.statusText}`,
+                    ].join("\n"),
+                };
+            }
+            return {
+                success: true,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                message: [
+                    `Failed to access WordPress origin at ${this.origin}`,
+                    `Using API Key?: ${ProjectEnvUtils.getSafe("SITE_API_KEY") ? "Yes" : "No"}`,
+                    `The following error occurred:${err}`,
+                ].join("\n"),
+            };
+        }
     }
     async load() {
         console.setWorking(true);
@@ -62,15 +92,14 @@ export class Project {
           
           You should rename the folder to match the repo name, or vice versa.
         `);
-            if (cliMode.interactive) {
-                await clack.confirm({
-                    message: `Ignore and continue anyway?`,
-                });
-            }
-            else {
-                console.flush();
-                process.exit(1);
-            }
+            // if (cliMode.interactive) {
+            //   await clack.confirm({
+            //     message: `Ignore and continue anyway?`,
+            //   })
+            // } else {
+            //   console.flush()
+            //   process.exit(1)
+            // }
         }
         /**
          * Load configuration

package/dist/node/project/wp-info.d.ts

@@ -26,6 +26,7 @@ export declare class WPInfo {
     siteUrl: string;
     private cached?;
     constructor(siteUrl: string);
+    ping(): Promise<Response>;
     getInfo(force?: boolean): Promise<WPInfoData>;
     getPluginIssues(): Promise<string[]>;
 }

package/dist/node/project/wp-info.js

@@ -1,17 +1,27 @@
 import { resolveURL } from "ufo";
-import { getUnsafeFetch } from "../utils/unsafe-fetch.js";
+import { fetchWP } from "../utils/fetch-wp.js";
 export class WPInfo {
     siteUrl;
     cached;
     constructor(siteUrl) {
         this.siteUrl = siteUrl;
     }
+    async ping() {
+        if (!this.siteUrl) {
+            throw new Error("Attempted to ping WordPress, but SITE_URL was not present in the environment.");
+        }
+        const url = resolveURL(this.siteUrl, "/wp-json/ed/v1/handshake");
+        const response = await fetchWP(url);
+        return response;
+    }
     async getInfo(force = false) {
+        if (!this.siteUrl) {
+            throw new Error("Attempted to get site info from WordPress, but SITE_URL was not present in the environment.");
+        }
         if (this.cached && !force)
             return this.cached;
         const url = resolveURL(this.siteUrl, "/wp-json/ed/v1/dev/site-info");
-        const fetch = getUnsafeFetch(this.siteUrl);
-        const response = await fetch(url);
+        const response = await fetchWP(url);
         const result = (await response.json());
         this.cached = result;
         return result;

package/dist/node/types/block-type.d.ts

@@ -23,67 +23,72 @@ export declare const BlockMetaSchema: z.ZodObject<{
     cache: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     allowMultiple: z.ZodDefault<z.ZodBoolean>;
     postMetaBlock: z.ZodOptional<z.ZodObject<{
+        postTypes: z.ZodArray<z.ZodString, "many">;
         fieldName: z.ZodString;
     }, "strip", z.ZodTypeAny, {
+        postTypes: string[];
         fieldName: string;
     }, {
+        postTypes: string[];
         fieldName: string;
     }>>;
     frontendMode: z.ZodDefault<z.ZodEnum<["hidden", "childrenOnly", "default"]>>;
     inserter: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    cache: boolean;
+    title: string;
+    mode: "both" | "edit" | "preview";
+    slug: string;
+    tags: string[];
+    flags: Record<string, any>;
+    category: string;
+    parent: string[];
     acfName: string;
     fileName: string;
-    slug: string;
     graphqlFieldName: string;
-    title: string;
-    category: string;
     types: string[];
-    mode: "preview" | "edit" | "both";
-    tags: string[];
-    flags: Record<string, any>;
     childTags: string[];
     childBlocks: string[];
-    parent: string[];
     ancestors: string[];
     dynamic: boolean;
+    cache: boolean;
     allowMultiple: boolean;
-    frontendMode: "hidden" | "childrenOnly" | "default";
+    frontendMode: "hidden" | "default" | "childrenOnly";
     inserter: boolean;
-    description?: string | undefined;
     icon?: string | undefined;
+    description?: string | undefined;
     keywords?: string[] | undefined;
     templates?: string[] | null | undefined;
     postMetaBlock?: {
+        postTypes: string[];
         fieldName: string;
     } | undefined;
 }, {
+    title: string;
+    slug: string;
     acfName: string;
     fileName: string;
-    slug: string;
     graphqlFieldName: string;
-    title: string;
     types: string[];
-    cache?: boolean | undefined;
-    description?: string | undefined;
-    category?: string | undefined;
+    mode?: "both" | "edit" | "preview" | undefined;
+    tags?: string[] | undefined;
+    flags?: Record<string, any> | undefined;
     icon?: string | undefined;
+    category?: string | undefined;
+    parent?: string[] | undefined;
+    description?: string | undefined;
     keywords?: string[] | undefined;
     templates?: string[] | null | undefined;
-    mode?: "preview" | "edit" | "both" | undefined;
-    tags?: string[] | undefined;
-    flags?: Record<string, any> | undefined;
     childTags?: string[] | undefined;
     childBlocks?: string[] | undefined;
-    parent?: string[] | undefined;
     ancestors?: string[] | undefined;
     dynamic?: boolean | undefined;
+    cache?: boolean | undefined;
     allowMultiple?: boolean | undefined;
     postMetaBlock?: {
+        postTypes: string[];
         fieldName: string;
     } | undefined;
-    frontendMode?: "hidden" | "childrenOnly" | "default" | undefined;
+    frontendMode?: "hidden" | "default" | "childrenOnly" | undefined;
     inserter?: boolean | undefined;
 }>;
 export type BlockMetadata = z.infer<typeof BlockMetaSchema>;

package/dist/node/types/block-type.js

@@ -27,6 +27,7 @@ export const BlockMetaSchema = z.object({
     allowMultiple: z.boolean().default(true),
     postMetaBlock: z
         .object({
+        postTypes: z.array(z.string()),
         fieldName: z.string(),
     })
         .optional(),

package/dist/node/types/view-type.d.ts

@@ -9,21 +9,21 @@ export declare const ViewMetaSchema: z.ZodObject<{
     routePattern: z.ZodOptional<z.ZodString>;
     postType: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
 }, "strip", z.ZodTypeAny, {
-    cache: boolean;
-    fileName: string;
-    slug: string;
     title: string;
+    slug: string;
+    fileName: string;
+    cache: boolean;
     isCustomTemplate: boolean;
-    routePattern?: string | undefined;
     postType?: string[] | undefined;
+    routePattern?: string | undefined;
 }, {
-    fileName: string;
-    slug: string;
     title: string;
+    slug: string;
+    fileName: string;
+    postType?: string[] | undefined;
     cache?: boolean | undefined;
     isCustomTemplate?: boolean | undefined;
     routePattern?: string | undefined;
-    postType?: string[] | undefined;
 }>;
 export type ViewMetadata = z.infer<typeof ViewMetaSchema>;
 export type ViewMetadataConstructor = z.input<typeof ViewMetaSchema>;

package/dist/node/types/view-type.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { objFormat } from "obj-console";
-import { console } from "../utils/console.js";
 import chalk from "chalk";
 import { indent } from "../utils/helpers.js";
 export const ViewMetaSchema = z.object({
@@ -28,7 +27,7 @@ export function describeView(view) {
     return output;
 }
 export function describeViewManifest(manifest) {
-    console.heading("View Manifest");
+    console.log("View Manifest");
     console.info("Discovered " + Object.keys(manifest.views).length + " view(s)");
     const totalWarnings = manifest.validationMessages.filter((m) => m.severity === "warning").length;
     const totalErrors = manifest.validationMessages.filter((m) => m.severity === "error").length;
@@ -48,7 +47,7 @@ export function describeViewManifest(manifest) {
         console.log(indent(4, describeView(view)));
     }
     if (totalWarnings > 0)
-        console.failish(totalWarnings + " warning(s) while loading view metadata");
+        console.warn(totalWarnings + " warning(s) while loading view metadata");
     if (totalErrors > 0)
-        console.fail(totalErrors + " error(s) while loading view metadata");
+        console.warn(totalErrors + " error(s) while loading view metadata");
 }

package/dist/node/utils/fetch-wp.d.ts

@@ -0,0 +1 @@
+export declare function fetchWP(url: string | URL, args?: RequestInit): Promise<Response>;

package/dist/node/utils/fetch-wp.js

@@ -0,0 +1,27 @@
+import { ProjectEnvUtils } from "../project/env.js";
+import { Agent, fetch, setGlobalDispatcher, Headers } from "undici";
+const agent = new Agent({
+    connect: {
+        rejectUnauthorized: false,
+    },
+});
+export function fetchWP(url, args = {}) {
+    const headers = new Headers(args.headers);
+    // If an API key has been set in the environment, use it
+    const accessKey = ProjectEnvUtils.getSafe("SITE_API_KEY");
+    if (accessKey) {
+        headers.set("x-ed-api-key", accessKey);
+    }
+    // Allow self-signed certificates when using a local development domain
+    let allowSelfSigned = isDevelopmentDomain(url);
+    return fetch(url, {
+        ...args,
+        dispatcher: allowSelfSigned ? agent : undefined,
+        headers,
+    });
+}
+setGlobalDispatcher(agent);
+function isDevelopmentDomain(url) {
+    const hostname = typeof url === "string" ? new URL(url).hostname : url.hostname;
+    return !!hostname?.match(/(^[0-9\.]+$|\.local$)/);
+}

package/dist/node/utils/fs-codegen.d.ts

@@ -0,0 +1,42 @@
+import { Code } from "ts-poet";
+import { Project } from "../project/project.js";
+type VirtualFile = {
+    name: string;
+    content: string | Code;
+};
+type CodeGenerator = {
+    getFiles(): Promise<VirtualFile | VirtualFile[] | null>;
+    susbcribe?(callback: () => void): () => void;
+};
+/**
+ * A codegen utility that allows you to procedurally and reactively generate files, to be flushed to the FS.
+ */
+export declare class FSCodegen {
+    project: Project;
+    opts: {
+        outDir: string;
+        onWritten?: (opts: Set<string>) => void;
+    };
+    outDir: string;
+    private generators;
+    private generatorFiles;
+    private unsubscribers;
+    private flushScheduled;
+    constructor(project: Project, opts: {
+        outDir: string;
+        onWritten?: (opts: Set<string>) => void;
+    });
+    register(generator: CodeGenerator): void;
+    registerFile({ name, generate, subscribe, }: {
+        name: string;
+        generate: (() => string | Code | Promise<string | Code>) | string | Code;
+        subscribe?: (callback: () => void) => () => void;
+    }): void;
+    private runGenerator;
+    scheduleFlush(): void;
+    runAndWatch(): Promise<void>;
+    run(): Promise<void>;
+    private flush;
+    stop(): void;
+}
+export {};

package/dist/node/utils/fs-codegen.js

@@ -0,0 +1,98 @@
+import { Code } from "ts-poet";
+import { globby } from "globby";
+import { fs } from "./fs.js";
+import { join, resolve } from "path";
+/**
+ * A codegen utility that allows you to procedurally and reactively generate files, to be flushed to the FS.
+ */
+export class FSCodegen {
+    project;
+    opts;
+    outDir;
+    generators = new Set();
+    generatorFiles = new Map();
+    unsubscribers = new Set();
+    flushScheduled = false;
+    constructor(project, opts) {
+        this.project = project;
+        this.opts = opts;
+        this.outDir = opts.outDir;
+    }
+    register(generator) {
+        this.generators.add(generator);
+    }
+    registerFile({ name, generate, subscribe, }) {
+        this.register({
+            async getFiles() {
+                return {
+                    name,
+                    content: generate instanceof Code ? generate.toString() : typeof generate === "string" ? generate : await generate(),
+                };
+            },
+            susbcribe: subscribe,
+        });
+    }
+    async runGenerator(generator) {
+        const files = await generator.getFiles();
+        this.generatorFiles.set(generator, files ? (Array.isArray(files) ? files : [files]) : []);
+        this.scheduleFlush();
+    }
+    scheduleFlush() {
+        if (this.flushScheduled) {
+            return;
+        }
+        this.flushScheduled = true;
+        setTimeout(() => {
+            this.flushScheduled = false;
+            this.flush();
+        }, 100);
+    }
+    async runAndWatch() {
+        await Promise.all(Array.from(this.generators).map((generator) => {
+            return new Promise((resolve) => {
+                let first = true;
+                if (generator.susbcribe) {
+                    // Subscribe and run at least once
+                    this.unsubscribers.add(generator.susbcribe(() => {
+                        if (first) {
+                            first = false;
+                            this.runGenerator(generator).then(resolve);
+                        }
+                        else {
+                            this.runGenerator(generator);
+                        }
+                    }));
+                }
+                else {
+                    // Just run once, since there is no subscriber
+                    this.runGenerator(generator).then(resolve);
+                }
+            });
+        }));
+        await this.flush();
+    }
+    async run() {
+        await Promise.all(Array.from(this.generators).map((generator) => this.runGenerator(generator)));
+        await this.flush();
+    }
+    async flush() {
+        const files = Array.from(this.generatorFiles.values()).flat();
+        const existing = (await globby(join(this.outDir, "/**/*"))).map((path) => resolve(this.project.rootDir, path));
+        const written = new Set();
+        await Promise.all(files.map(async (file) => {
+            const path = join(this.project.rootDir, this.outDir, file.name);
+            written.add(resolve(this.project.rootDir, path));
+            await fs.writeIfUnchanged(path, file.content.toString());
+        }));
+        await Promise.all(existing.map(async (path) => {
+            if (!written.has(path)) {
+                await fs.rm(path);
+            }
+        }));
+        this.opts.onWritten?.(written);
+    }
+    stop() {
+        this.unsubscribers.forEach((unsub) => unsub());
+        this.unsubscribers.clear();
+    }
+}

package/dist/node/utils/fs.js

@@ -1,7 +1,9 @@
 import * as nodeFs from "fs/promises";
+import { dirname } from "path";
 export const fs = {
     ...nodeFs,
     writeIfUnchanged: async (path, content) => {
+        await fs.mkdirp(dirname(path));
         try {
             const currentContent = await nodeFs.readFile(path, "utf8");
             if (currentContent === content)

package/dist/node/utils/{isDeploying.js → is-deploying.js}

@@ -2,5 +2,5 @@
  * Returns true if we think that the compiler is running in a deployment context (Vercel, GitHub Actions, etc.)
  */
 export function isDeploying() {
-    return !!process.env.VERCEL;
+    return !!process.env.VERCEL || !!process.env.GITHUB_ACTIONS;
 }

package/dist/node/utils/{selfSignedCert.js → self-signed-cert.js}

@@ -1,4 +1,4 @@
-import { serverlessLog } from "../compiler/serverless.dev.js";
+import { serverlessLog } from "../compiler/dev-server.js";
 import { fs } from "./fs.js";
 import { createCA, createCert } from "mkcert";
 export async function ensureSelfSignedCert(hostname, rootDir) {

package/dist/node/utils/{statefulLog.js → stateful-log.js}

@@ -1,5 +1,5 @@
 import { cliMode } from "../cli/cli-mode.js";
-import { eachFormattedZodError } from "./formatZodError.js";
+import { eachFormattedZodError } from "./format-zod-error.js";
 import chalk from "chalk";
 let logId = 0;
 const getID = () => logId++;
@@ -133,6 +133,8 @@ export class StatefulLog {
         this.notifySubscribers();
     }
     addLogEntry(kind, ...messages) {
+        // We ignore SSL errors in dev mode.
+        // if (typeof messages[0] === "string" && messages[0].includes("NODE_TLS_REJECT_UNAUTHORIZED")) return
         if (cliMode.interactive) {
             const entry = {
                 id: getID(),

package/dist/node/utils/watch-file-tree.d.ts

@@ -0,0 +1,25 @@
+type FileList = string[];
+type Disposer = () => void;
+export type FileWatchEvent = "added" | "deleted" | "changed";
+export type FileEvent = {
+    type: FileWatchEvent;
+    file: string;
+};
+type WatchTreeOpts = {
+    pattern: string | string[];
+    ignore?: string[];
+    callback: (files: FileList, event?: FileEvent) => void;
+};
+export declare function watchFileTree({ pattern, callback, ignore }: WatchTreeOpts): Promise<Disposer>;
+type WatchTreeChangesOpts = {
+    pattern: string | string[];
+    ignore?: string | RegExp | string[];
+    callback: (event: FileEvent) => void;
+};
+export declare function watchFileTreeForChanges({ pattern, callback, ignore }: WatchTreeChangesOpts): Promise<Disposer>;
+type GetTreeOpts = {
+    pattern: string | string[];
+    ignore?: string[];
+};
+export declare function getFileTree(opts: GetTreeOpts): Promise<FileList>;
+export {};

package/dist/node/utils/{watchFileTree.js → watch-file-tree.js}

@@ -1,11 +1,13 @@
 import chokidar from "chokidar";
 import { globby } from "globby";
-export function watchFileTree(pattern, callback) {
+export function watchFileTree({ pattern, callback, ignore }) {
     const files = [];
     let ready = false;
     return new Promise((resolve) => {
         const watcher = chokidar
-            .watch(pattern)
+            .watch(pattern, {
+            ignored: ignore,
+        })
             .on("add", (path) => {
             files.push(path);
             if (ready)
@@ -31,7 +33,7 @@ export function watchFileTree(pattern, callback) {
         });
     });
 }
-export function watchFileTreeForChanges(pattern, callback) {
+export function watchFileTreeForChanges({ pattern, callback, ignore }) {
     let ready = false;
     return new Promise((resolve) => {
         const watcher = chokidar
@@ -50,9 +52,14 @@ export function watchFileTreeForChanges(pattern, callback) {
         })
             .on("ready", () => {
             ready = true;
+            resolve(() => {
+                watcher.close();
+            });
         });
     });
 }
-export function getFileTree(pattern) {
-    return globby(pattern);
+export function getFileTree(opts) {
+    return globby(opts.pattern, {
+        ignore: opts.ignore,
+    });
 }