eddev 2.0.0-beta.64 → 2.0.0-beta.66

package/dist/app/server/server-context.d.ts

@@ -2,11 +2,13 @@ import { RequestHeaders } from "vinxi/http";
 import { UrlReplacerConf } from "./utils/replace-host.js";
 import { Manifest } from "vinxi/dist/types/types/manifest";
 import { TrackerTags } from "../lib/routing/types.js";
+import type { EDConfig } from "../../node/project/config.js";
 export type ServerContextArgs = {
     dev: boolean;
     origin: string;
     replaceUrls?: UrlReplacerConf;
     rpcBases?: string[];
+    config: EDConfig;
 };
 export type ServerContextRuntime = {
     getManifest: (name: string) => Manifest;
@@ -23,6 +25,7 @@ export declare class ServerContext {
     origin: string;
     replaceUrls?: (text: string) => string;
     rpcBases: string[];
+    config: EDConfig;
     static main: ServerContext;
     constructor(conf: ServerContextArgs);
     get runtime(): ServerContextRuntime;
@@ -49,5 +52,20 @@ export declare class ServerContext {
         body: object;
         headers: RequestHeaders;
     }): Promise<Response>;
+    get allowedCorsOrigins(): string[];
+    getCorsOrigin(originHeader: string): string | undefined;
+    getCorsHeaders(origin: string): {
+        "Access-Control-Allow-Methods"?: undefined;
+        "Access-Control-Allow-Origin"?: undefined;
+        "Access-Control-Allow-Credentials"?: undefined;
+        "Access-Control-Allow-Headers"?: undefined;
+        "Access-Control-Expose-Headers"?: undefined;
+    } | {
+        "Access-Control-Allow-Methods": string;
+        "Access-Control-Allow-Origin": string;
+        "Access-Control-Allow-Credentials": string;
+        "Access-Control-Allow-Headers": string;
+        "Access-Control-Expose-Headers": string;
+    };
 }
 export {};

package/dist/app/server/server-context.js

@@ -19,11 +19,13 @@ export class ServerContext {
     origin;
     replaceUrls;
     rpcBases = [];
+    config;
     static main;
     constructor(conf) {
         this.dev = conf.dev;
         this.origin = conf.origin;
         this.rpcBases = conf.rpcBases ?? [];
+        this.config = conf.config;
         if (conf.replaceUrls) {
             this.replaceUrls = createUrlReplacer(conf.replaceUrls);
         }
@@ -146,4 +148,40 @@ export class ServerContext {
             redirect: "manual",
         });
     }
+    get allowedCorsOrigins() {
+        let result = [];
+        if (this.config.serverless.endpoints) {
+            result.push(...Object.keys(this.config.serverless.endpoints));
+            result.push(...Object.values(this.config.serverless.endpoints));
+            result = result.filter((origin) => origin !== "*");
+        }
+        if (this.config.serverless.cors?.origins) {
+            result.push(...this.config.serverless.cors.origins);
+        }
+        return result;
+    }
+    getCorsOrigin(originHeader) {
+        const parsed = parseURL(originHeader);
+        if (this.allowedCorsOrigins.includes(parsed.host)) {
+            return originHeader;
+        }
+        if (this.allowedCorsOrigins.includes("*")) {
+            return "*";
+        }
+    }
+    getCorsHeaders(origin) {
+        if (!origin)
+            return {};
+        const allowedOrigin = this.getCorsOrigin(origin);
+        if (allowedOrigin) {
+            return {
+                "Access-Control-Allow-Methods": "OPTIONS,GET,HEAD,PUT,PATCH,POST,DELETE",
+                "Access-Control-Allow-Origin": allowedOrigin,
+                "Access-Control-Allow-Credentials": "true",
+                "Access-Control-Allow-Headers": "*",
+                "Access-Control-Expose-Headers": "*",
+            };
+        }
+        return {};
+    }
 }

package/dist/app/utils/trpc-client.js

@@ -1,6 +1,11 @@
 import { createTRPCUntypedClient, httpLink, splitLink, unstable_httpSubscriptionLink, } from "@trpc/client";
 import SuperJSON from "superjson";
 import { parseURL, stringifyParsedURL } from "ufo";
+const updatePath = (url) => {
+    const parsed = parseURL(url);
+    parsed.pathname = "/" + parsed.pathname.replace(/(^\/|\/$)/g, "").replace(/\./g, "/") + "/";
+    return stringifyParsedURL(parsed);
+};
 let client;
 export function getRPCClient() {
     if (env.rpcEnabled) {
@@ -10,7 +15,6 @@ export function getRPCClient() {
             client = createTRPCUntypedClient({
                 links: [
                     splitLink({
-                        // uses the httpSubscriptionLink for subscriptions
                         condition: (op) => op.type === "subscription",
                         true: unstable_httpSubscriptionLink({
                             url: endpoint,
@@ -18,10 +22,11 @@ export function getRPCClient() {
                         }),
                         false: httpLink({
                             url: endpoint,
-                            fetch: (input, init) => {
-                                const parsed = parseURL(input);
-                                parsed.pathname = "/" + parsed.pathname.replace(/(^\/|\/$)/g, "").replace(/\./g, "/") + "/";
-                                return fetch(stringifyParsedURL(parsed), init);
+                            fetch: (url, opts) => {
+                                return fetch(updatePath(url), {
+                                    ...opts,
+                                    credentials: "omit",
+                                });
                             },
                             transformer: SuperJSON,
                         }),

package/dist/node/cli/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "2.0.0-beta.62";
+export declare const VERSION = "2.0.0-beta.66";

package/dist/node/cli/version.js

@@ -1 +1 @@
-export const VERSION = "2.0.0-beta.62";
+export const VERSION = "2.0.0-beta.66";

package/dist/node/compiler/build-vinxi.js

@@ -17,8 +17,8 @@ export async function buildVinxi(opts) {
         publicUrl: project.publicUrl,
         rootDir: project.rootDir,
         rpcBases: (await project.serverRoutes.get()).bases,
-        // log: console,
         preset,
+        config: project.config,
     };
     const codegen = createVinxiCodegen({
         mode: "production",

package/dist/node/compiler/dev-server.js

@@ -40,6 +40,7 @@ export class DevServer {
             rootDir: this.project.rootDir,
             log: console,
             rpcBases: (await this.project.serverRoutes.get()).bases,
+            config: this.project.config,
         });
         const preset = process.env.TARGET ??
             process.env.PRESET ??

package/dist/node/compiler/vinxi-app.d.ts

@@ -1,4 +1,5 @@
 import { StatefulLog } from "../utils/stateful-log.js";
+import { EDConfig } from "../project/config.js";
 export type AppArgs = {
     mode: "development" | "production";
     publicUrl: string;
@@ -8,6 +9,7 @@ export type AppArgs = {
     preset?: string;
     routes?: CustomRoute[];
     rpcBases?: string[];
+    config: EDConfig;
 };
 type HTTPMethod = "GET" | "POST" | "PUT" | "OPTIONS" | "HEAD";
 type CustomRouteFunction = (req: Request) => Response;

package/dist/node/compiler/vinxi-app.js

@@ -11,16 +11,6 @@ export function createVinxiApp(args) {
             mode: args.mode,
             serverless: true,
         });
-    console.log("Creating Vinxi app with args", args.rpcBases);
-    console.log("Base routes", args.rpcBases?.reduce((acc, base) => {
-        return {
-            ...acc,
-            ["/" + base.replace(/(^\/|\/$)/g, "") + "/**/*"]: {
-                isr: false,
-                swr: false,
-            },
-        };
-    }, {}));
     return createApp({
         server: {
             // experimental: {

package/dist/node/compiler/vinxi-codegen.js

@@ -31,6 +31,7 @@ export function createVinxiCodegen(opts) {
                         ],
                     },
                     rpcBases: (await project.serverRoutes.get()).bases ?? [],
+                    config: project.config,
                 };
                 return code /* tsx */ `
           import { ServerContext } from "eddev/server"
@@ -467,10 +468,21 @@ export function createVinxiCodegen(opts) {
         import "./context.js"
         import { fetchRequestHandler } from "@trpc/server/adapters/fetch"
         import { parseURL, stringifyParsedURL } from "ufo"
-        import { EventHandlerRequest, getWebRequest, H3Event } from "vinxi/http"
+        import { EventHandlerRequest, getWebRequest, H3Event, setResponseHeaders } from "vinxi/http"
         import { createContext, router } from "./manifest/routes.ts"
+        import { ServerContext } from "eddev/server"
 
         export function handleRPC(event: H3Event<EventHandlerRequest>) {
+          const serverContext = ServerContext.main
+          
+          // Handle CORS
+          setResponseHeaders(event, serverContext.getCorsHeaders(event.headers.get("origin") ?? event.headers.get("referer") ?? ""))
+          if (event.method === "OPTIONS") {
+            event.node.res.statusCode = 204
+            event.node.res.statusMessage = "No Content."
+            return "OK"
+          }
+            
           // Update URLs with dots, which tRPC prefers
           const originalReq = getWebRequest(event)
           const parsed = parseURL(originalReq.url)

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

@@ -9,20 +9,20 @@ export declare const EDConfigSchema: z.ZodObject<{
         provider: z.ZodLiteral<"ga4">;
         id: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        provider: "ga4";
         id: string;
-    }, {
         provider: "ga4";
+    }, {
         id: string;
+        provider: "ga4";
     }>, z.ZodObject<{
         provider: z.ZodLiteral<"gtm">;
         id: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        provider: "gtm";
         id: string;
-    }, {
         provider: "gtm";
+    }, {
         id: string;
+        provider: "gtm";
     }>]>, "many">>;
     serverless: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -33,24 +33,37 @@ export declare const EDConfigSchema: z.ZodObject<{
         endpoints: z.ZodRecord<z.ZodString, z.ZodString>;
         defaultRevalidate: z.ZodOptional<z.ZodNumber>;
         defaultRevalidateQueries: z.ZodOptional<z.ZodNumber>;
+        cors: z.ZodOptional<z.ZodObject<{
+            origins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            origins?: string[] | undefined;
+        }, {
+            origins?: string[] | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
+        plugins: "proxy" | "remote";
         enabled: boolean;
         uploads: "proxy" | "remote";
-        plugins: "proxy" | "remote";
         themeAssets: string[];
         apiOnly: boolean;
         endpoints: Record<string, string>;
         defaultRevalidate?: number | undefined;
         defaultRevalidateQueries?: number | undefined;
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
     }, {
         uploads: "proxy" | "remote";
         endpoints: Record<string, string>;
-        enabled?: boolean | undefined;
         plugins?: "proxy" | "remote" | undefined;
+        enabled?: boolean | undefined;
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
         defaultRevalidate?: number | undefined;
         defaultRevalidateQueries?: number | undefined;
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
     }>;
     cache: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         props: z.ZodNumber;
@@ -68,55 +81,61 @@ export declare const EDConfigSchema: z.ZodObject<{
     legacyMetadata: boolean;
     legacyStitches: boolean;
     serverless: {
+        plugins: "proxy" | "remote";
         enabled: boolean;
         uploads: "proxy" | "remote";
-        plugins: "proxy" | "remote";
         themeAssets: string[];
         apiOnly: boolean;
         endpoints: Record<string, string>;
         defaultRevalidate?: number | undefined;
         defaultRevalidateQueries?: number | undefined;
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
     };
-    devUI: "enabled" | "disabled";
+    devUI: "disabled" | "enabled";
+    cache?: Record<string, {
+        props: number;
+        queries: number;
+    }> | undefined;
     $schema?: string | undefined;
     trackers?: ({
-        provider: "ga4";
         id: string;
+        provider: "ga4";
     } | {
-        provider: "gtm";
         id: string;
+        provider: "gtm";
     })[] | undefined;
-    cache?: Record<string, {
-        props: number;
-        queries: number;
-    }> | undefined;
 }, {
     version: "1" | "2";
     serverless: {
         uploads: "proxy" | "remote";
         endpoints: Record<string, string>;
-        enabled?: boolean | undefined;
         plugins?: "proxy" | "remote" | undefined;
+        enabled?: boolean | undefined;
         themeAssets?: string[] | undefined;
         apiOnly?: boolean | undefined;
         defaultRevalidate?: number | undefined;
         defaultRevalidateQueries?: number | undefined;
+        cors?: {
+            origins?: string[] | undefined;
+        } | undefined;
     };
+    cache?: Record<string, {
+        props: number;
+        queries: number;
+    }> | undefined;
     $schema?: string | undefined;
     legacyMetadata?: boolean | undefined;
     legacyStitches?: boolean | undefined;
     trackers?: ({
-        provider: "ga4";
         id: string;
+        provider: "ga4";
     } | {
-        provider: "gtm";
         id: string;
+        provider: "gtm";
     })[] | undefined;
-    cache?: Record<string, {
-        props: number;
-        queries: number;
-    }> | undefined;
-    devUI?: "enabled" | "disabled" | undefined;
+    devUI?: "disabled" | "enabled" | undefined;
 }>;
 export type EDConfig = z.infer<typeof EDConfigSchema>;
 export declare class Configurator {

package/dist/node/project/config.js

@@ -49,6 +49,14 @@ export const EDConfigSchema = z.object({
             .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(),
+        cors: z
+            .object({
+            origins: z
+                .array(z.string())
+                .optional()
+                .describe("A list of allowed origins for CORS. Set to ['*'] to allow all. All WordPress hosts are also allowed."),
+        })
+            .optional(),
     }),
     cache: z
         .record(z.string(), z.object({

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

@@ -35,27 +35,27 @@ export declare const BlockMetaSchema: z.ZodObject<{
     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?: {
@@ -63,32 +63,32 @@ export declare const BlockMetaSchema: z.ZodObject<{
         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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eddev",
-  "version": "2.0.0-beta.64",
+  "version": "2.0.0-beta.66",
   "description": "",
   "main": "index.js",
   "type": "module",