eddev 2.0.0-beta.60 → 2.0.0-beta.61

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

@@ -6,6 +6,7 @@ export type ServerContextArgs = {
     dev: boolean;
     origin: string;
     replaceUrls?: UrlReplacerConf;
+    rpcBases?: string[];
 };
 export type ServerContextRuntime = {
     getManifest: (name: string) => Manifest;
@@ -21,6 +22,7 @@ export declare class ServerContext {
     dev: boolean;
     origin: string;
     replaceUrls?: (text: string) => string;
+    rpcBases: string[];
     static main: ServerContext;
     constructor(conf: ServerContextArgs);
     get runtime(): ServerContextRuntime;

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

@@ -18,10 +18,12 @@ export class ServerContext {
     dev;
     origin;
     replaceUrls;
+    rpcBases = [];
     static main;
     constructor(conf) {
         this.dev = conf.dev;
         this.origin = conf.origin;
+        this.rpcBases = conf.rpcBases ?? [];
         if (conf.replaceUrls) {
             this.replaceUrls = createUrlReplacer(conf.replaceUrls);
         }

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

@@ -1 +1 @@
-export declare const VERSION = "2.0.0-beta.60";
+export declare const VERSION = "2.0.0-beta.61";

package/dist/node/cli/version.js

@@ -1 +1 @@
-export const VERSION = "2.0.0-beta.60";
+export const VERSION = "2.0.0-beta.61";

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

@@ -77,24 +77,6 @@ export function createVinxiApp(args) {
                 dir: "./assets",
                 base: joinURL(args.publicUrl, "assets"),
             },
-            {
-                name: "trpc-api",
-                type: "http",
-                base: "/trpc/",
-                handler: `${folder}/handler.trpc-api.ts`,
-                target: "server",
-                plugins: () => [
-                    tsconfigPaths(),
-                    envPlugin({
-                        rootDir: args.rootDir,
-                        console: log,
-                        mode: args.mode,
-                        publicUrl: args.publicUrl,
-                        serverless: true,
-                        target: "frontend",
-                    }),
-                ],
-            },
             {
                 name: "data-api",
                 type: "http",
@@ -165,24 +147,24 @@ export function createVinxiApp(args) {
                 ],
                 base: "/_admin",
             },
-            ...(args.rpcBases ?? []).map((base) => ({
-                name: "trpc-api",
-                type: "http",
-                base: "/" + base.replace(/^\//, ""),
-                handler: `${folder}/handler.trpc-api.ts`,
-                target: "server",
-                plugins: () => [
-                    tsconfigPaths(),
-                    envPlugin({
-                        rootDir: args.rootDir,
-                        console: log,
-                        mode: args.mode,
-                        publicUrl: args.publicUrl,
-                        serverless: true,
-                        target: "frontend",
-                    }),
-                ],
-            })),
+            // ...((args.rpcBases ?? []).map((base) => ({
+            //   name: "trpc" + base.replace(/^\//, "-"),
+            //   type: "http",
+            //   base: "/" + base.replace(/^\//, ""),
+            //   handler: `${folder}/handler.trpc-api.ts`,
+            //   target: "server",
+            //   plugins: () => [
+            //     tsconfigPaths(),
+            //     envPlugin({
+            //       rootDir: args.rootDir,
+            //       console: log,
+            //       mode: args.mode,
+            //       publicUrl: args.publicUrl,
+            //       serverless: true,
+            //       target: "frontend",
+            //     }),
+            //   ],
+            // })) as RouterSchemaInput[]),
             {
                 name: "ssr",
                 type: "http",

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

@@ -18,7 +18,7 @@ export function createVinxiCodegen(opts) {
     if (opts.serverless) {
         codegen.registerFile({
             name: "context.ts",
-            generate: () => {
+            generate: async () => {
                 const args = {
                     dev: true,
                     origin: project.origin,
@@ -30,6 +30,7 @@ export function createVinxiCodegen(opts) {
                             { prefix: "/wp-content/plugins", replace: project.config?.serverless.plugins === "proxy" },
                         ],
                     },
+                    rpcBases: (await project.serverRoutes.get()).bases ?? [],
                 };
                 return code /* tsx */ `
           import { ServerContext } from "eddev/server"
@@ -248,56 +249,25 @@ export function createVinxiCodegen(opts) {
         import "./manifest/styles.js"
         import "./manifest/views.js"
         import "./context.js"
-
+        import { handleRPC } from "./rpc.js"
         import { proxyWpAdmin, ServerContext, renderPage } from "eddev/server"
         import { eventHandler, getRequestURL } from "vinxi/http"
-        import { RouteData } from "eddev/routing"
 
         export default eventHandler({
           handler: async (event) => {
             const serverContext = ServerContext.main
             const url = getRequestURL(event)
 
+            const isRPC = serverContext.rpcBases.some((base) => url.pathname.startsWith(base))
+            if (isRPC) {
+              return handleRPC(event)
+            }
+
             if (url.pathname.includes(".")) {
               return proxyWpAdmin(event)
             }
 
             return renderPage({ pathname: url.pathname })
-
-          //   try {
-          //     const [{appData, trackers}, response] = await Promise.all([
-          //       serverContext.fetchAppData(),
-          //       serverContext.fetchRouteData({
-          //         pathname: url.pathname,
-          //         withAppData: false,
-          //         headers: {},
-          //         query: {},
-          //       }),
-          //     ])
-
-          //     let data: RouteData
-          //     try {
-          //       data = await response.json()
-          //       data.appData = appData
-          //       data.trackers = trackers
-          //     } catch (err) {
-          //       data = {
-          //         view: "_error",
-          //         viewType: "react",
-          //         viewData: {},
-          //         appData: appData,
-          //       }
-          //       console.error(err)
-          //       setResponseStatus(event, 500)
-          //     }
-          //     setResponseHeader(event, "Content-Type", "text/html; charset=utf-8")
-          //     return renderPageToSSRStream(url.pathname, data)
-          //   } catch (err) {
-          //     console.error(err)
-          //     setResponseStatus(event, 500)
-          //     setResponseHeader(event, "Content-Type", "text/html; charset=utf-8")
-          //     return '<!DOCTYPE html><html><head><title>500 Internal Server Error</title></head><body><h1>500 Internal Server Error</h1><p>"'+err.message+'"</p></body></html>'
-          //   }
           }
         })
     `,
@@ -491,55 +461,53 @@ export function createVinxiCodegen(opts) {
             subscribe: project.serverRoutes.subscribe,
         });
         codegen.registerFile({
-            name: "handler.trpc-api.ts",
+            name: "rpc.ts",
             generate: code /* tsx */ `
         /// <reference types="vinxi/types/server" />
         import "./context.js"
         import { fetchRequestHandler } from "@trpc/server/adapters/fetch"
-        import { eventHandler, getWebRequest } from "vinxi/http"
-        import { createContext, router } from "./manifest/routes.ts"
         import { parseURL, stringifyParsedURL } from "ufo"
+        import { EventHandlerRequest, getWebRequest, H3Event } from "vinxi/http"
+        import { createContext, router } from "./manifest/routes.ts"
 
-        export default eventHandler({
-          handler: async (event) => {
-            // Update URLs with dots, which tRPC prefers
-            const originalReq = getWebRequest(event)
-            const parsed = parseURL(originalReq.url)
-            parsed.pathname = "/" + parsed.pathname.replace(/(^\\/|\\/$)/g, "").replace(/\\//, ".")
-            const req = new Request(stringifyParsedURL(parsed), originalReq)
-
-            // Handle any early results which are Responses
-            function processEarlyResult(value: any): Response | undefined {
-              if (value instanceof Response) {
-                return value
-              }
+        export function handleRPC(event: H3Event<EventHandlerRequest>) {
+          // Update URLs with dots, which tRPC prefers
+          const originalReq = getWebRequest(event)
+          const parsed = parseURL(originalReq.url)
+          parsed.pathname = "/" + parsed.pathname.replace(/(^\\/|\\/$)/g, "").replace(/\\//, ".")
+          const req = new Request(stringifyParsedURL(parsed), originalReq)
+
+          // Handle any early results which are Responses
+          function processEarlyResult(value: any): Response | undefined {
+            if (value instanceof Response) {
+              return value
             }
+          }
 
-            return new Promise(async (resolve) => {
-              let sent = false
-              const defaultResponse = await fetchRequestHandler({
-                endpoint: "/",
-                req: req,
-                router: router,
-                createContext,
-                onError: (err) => console.error(err),
-                batching: { enabled: false },
-                // If a Response object is returned by a route, it will be sent as the response
-                responseMeta(opts) {
-                  const value = opts?.data?.[0]?.["result"]?.["data"]
-                  const response = processEarlyResult(value)
-                  if (response) {
-                    sent = true
-                    resolve(response)
-                  }
-                  return {}
-                },
-              })
-              if (sent) return
-              resolve(defaultResponse)
+          return new Promise(async (resolve) => {
+            let sent = false
+            const defaultResponse = await fetchRequestHandler({
+              endpoint: "/",
+              req: req,
+              router: router,
+              createContext,
+              onError: (err) => console.error(err),
+              batching: { enabled: false },
+              // If a Response object is returned by a route, it will be sent as the response
+              responseMeta(opts) {
+                const value = opts?.data?.[0]?.["result"]?.["data"]
+                const response = processEarlyResult(value)
+                if (response) {
+                  sent = true
+                  resolve(response)
+                }
+                return {}
+              },
             })
-          },
-        })
+            if (sent) return
+            resolve(defaultResponse)
+          })
+        }
       `,
         });
     }

package/package.json

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