@marko/run 0.0.1-beta5 → 0.0.1-beta7

package/dist/adapter/middleware.js

@@ -1,12 +1,32 @@
-// src/adapter/middleware.ts
-import * as webStream from "stream/web";
-import installCrypto from "@hattip/polyfills/crypto";
-installCrypto();
-for (const key of Object.keys(webStream)) {
-  if (!(key in global)) {
-    global[key] = webStream[key];
+// src/adapter/polyfill.ts
+import { ReadableStream as ReadableStream2, TransformStream, WritableStream } from "stream/web";
+import { webcrypto as crypto } from "crypto";
+import { fetch, Response, Request as Request2, Headers, FormData, File } from "undici";
+var globals = {
+  crypto,
+  fetch,
+  Response,
+  Request: Request2,
+  Headers,
+  ReadableStream: ReadableStream2,
+  TransformStream,
+  WritableStream,
+  FormData,
+  File
+};
+function installPolyfills() {
+  for (const name in globals) {
+    Object.defineProperty(globalThis, name, {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: globals[name]
+    });
   }
 }
+
+// src/adapter/middleware.ts
+installPolyfills();
 function getForwardedHeader(req, name) {
   const value = req.headers["x-forwarded-" + name];
   if (value) {
@@ -35,7 +55,7 @@ function getOrigin(req, protocol, host, trustProxy) {
   }
   return `${protocol}://${host}`;
 }
-function createMiddleware(router, options = {}) {
+function createMiddleware(fetch2, options = {}) {
   const { trustProxy = process.env.TRUST_PROXY === "1" } = options;
   let { origin = process.env.ORIGIN } = options;
   let protocol;
@@ -48,45 +68,28 @@ function createMiddleware(router, options = {}) {
     origin ?? (origin = getOrigin(req, protocol, host, trustProxy));
     const url = new URL(req.url, origin);
     const ip = req.ip || trustProxy && getForwardedHeader(req, "for") || req.socket.remoteAddress || "";
-    const requestContext = {
+    const headers = req.headers;
+    const body = req.method === "GET" || req.method === "HEAD" ? void 0 : req.socket ? req : new ReadableStream({
+      start(controller) {
+        req.on("data", (chunk) => controller.enqueue(chunk));
+        req.on("end", () => controller.close());
+        req.on("error", (err) => controller.error(err));
+      }
+    });
+    const request = new Request(url, {
       method: req.method,
-      url,
-      platform: {
-        ip,
-        request: req,
-        response: res,
-        setCookie(cookie) {
-          res.appendHeader("set-cookie", cookie);
-        }
+      headers,
+      body,
+      duplex: "half"
+    });
+    const response = await fetch2(request, {
+      ip,
+      request: req,
+      response: res,
+      setCookie(cookie) {
+        res.appendHeader("set-cookie", cookie);
       }
-    };
-    Object.defineProperty(requestContext, "request", {
-      get() {
-        const headers = req.headers;
-        const body = req.method === "GET" || req.method === "HEAD" ? void 0 : req.socket ? req : new ReadableStream({
-          start(controller) {
-            req.on("data", (chunk) => controller.enqueue(chunk));
-            req.on("end", () => controller.close());
-            req.on("error", (err) => controller.error(err));
-          }
-        });
-        const request = new Request(url, {
-          method: req.method,
-          headers,
-          body,
-          duplex: "half"
-        });
-        Object.defineProperty(this, "request", {
-          value: request,
-          enumerable: true,
-          configurable: true
-        });
-        return request;
-      },
-      enumerable: true,
-      configurable: true
     });
-    const response = await router(requestContext);
     if (!response) {
       if (next) {
         next();
@@ -163,6 +166,6 @@ function createMiddleware(router, options = {}) {
   };
 }
 export {
-  createMiddleware as default,
+  createMiddleware,
   getOrigin
 };

package/dist/adapter/polyfill.d.ts

@@ -0,0 +1 @@
+export declare function installPolyfills(): void;

package/dist/runtime/index.d.ts

@@ -1,11 +1,15 @@
 import type { HandlerLike, ParamsObject, Route, RouteContext } from "./types";
 declare global {
     namespace Marko {
-        interface Global {
-            context: RouteContext;
+        interface Global extends MarkoRun.CurrentContext {
+        }
+        interface Out {
+            global: Global;
         }
     }
     namespace MarkoRun {
+        const NotHandled: symbol;
+        const NotMatched: symbol;
         interface CurrentRoute extends Route {
         }
         interface CurrentContext extends RouteContext<CurrentRoute> {
@@ -14,4 +18,4 @@ declare global {
         function route<Params extends ParamsObject = {}, Meta = unknown>(handler: Handler<Params, Meta>): typeof handler;
     }
 }
-export type { HandlerLike, InputObject, InvokeRoute, MatchRoute, NextFunction, PathTemplate, RequestContext, Route, RouteContext, RouteContextExtensions, RouteHandler, RouteWithHandler, Router, ValidateHref, ValidatePath, } from "./types";
+export type { Fetch, HandlerLike, InputObject, Invoke, Match, NextFunction, PathTemplate, Route, RouteContext, RouteContextExtensions, RouteHandler, RouteWithHandler, RuntimeModule, ValidateHref, ValidatePath, } from "./types";

package/dist/runtime/internal.cjs

@@ -20,8 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/runtime/internal.ts
 var internal_exports = {};
 __export(internal_exports, {
-  RequestNotHandled: () => RequestNotHandled,
-  RequestNotMatched: () => RequestNotMatched,
+  NotHandled: () => NotHandled,
+  NotMatched: () => NotMatched,
   call: () => call,
   compose: () => compose,
   createInput: () => createInput,
@@ -31,17 +31,20 @@ __export(internal_exports, {
   notMatched: () => notMatched
 });
 module.exports = __toCommonJS(internal_exports);
-globalThis.MarkoRun ?? (globalThis.MarkoRun = {});
-globalThis.MarkoRun.route = (handler) => handler;
-var RequestNotHandled = Symbol();
-var RequestNotMatched = Symbol();
+var NotHandled = Symbol();
+var NotMatched = Symbol();
+globalThis.MarkoRun ?? (globalThis.MarkoRun = {
+  NotHandled,
+  NotMatched,
+  route(handler) {
+    return handler;
+  }
+});
 function createInput(context) {
   let existing;
   return (data) => {
     existing ?? (existing = {
-      $global: {
-        context
-      }
+      $global: context
     });
     return data ? Object.assign(existing, data) : existing;
   };
@@ -78,7 +81,7 @@ async function call(handler, next, context) {
       response = await handler(context, next);
     } catch (error) {
       if (error == null) {
-        throw RequestNotHandled;
+        throw NotHandled;
       } else if (error instanceof Response) {
         return error;
       }
@@ -86,7 +89,7 @@ async function call(handler, next, context) {
     }
   }
   if (response === null) {
-    throw RequestNotMatched;
+    throw NotMatched;
   }
   return response || next();
 }
@@ -136,8 +139,8 @@ function notMatched() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  RequestNotHandled,
-  RequestNotMatched,
+  NotHandled,
+  NotMatched,
   call,
   compose,
   createInput,

package/dist/runtime/internal.d.ts

@@ -1,6 +1,6 @@
 import type { InputObject, NextFunction, Route, RouteContext, RouteHandler } from "./types";
-export declare const RequestNotHandled: unique symbol;
-export declare const RequestNotMatched: unique symbol;
+export declare const NotHandled: unique symbol;
+export declare const NotMatched: unique symbol;
 export declare function createInput(context: RouteContext): (data: InputObject) => InputObject;
 export declare function call(handler: RouteHandler<Route>, next: NextFunction, context: RouteContext): Promise<Response>;
 export declare function compose(handlers: RouteHandler[]): RouteHandler;

package/dist/runtime/internal.js

@@ -1,15 +1,18 @@
 // src/runtime/internal.ts
-globalThis.MarkoRun ?? (globalThis.MarkoRun = {});
-globalThis.MarkoRun.route = (handler) => handler;
-var RequestNotHandled = Symbol();
-var RequestNotMatched = Symbol();
+var NotHandled = Symbol();
+var NotMatched = Symbol();
+globalThis.MarkoRun ?? (globalThis.MarkoRun = {
+  NotHandled,
+  NotMatched,
+  route(handler) {
+    return handler;
+  }
+});
 function createInput(context) {
   let existing;
   return (data) => {
     existing ?? (existing = {
-      $global: {
-        context
-      }
+      $global: context
     });
     return data ? Object.assign(existing, data) : existing;
   };
@@ -46,7 +49,7 @@ async function call(handler, next, context) {
       response = await handler(context, next);
     } catch (error) {
       if (error == null) {
-        throw RequestNotHandled;
+        throw NotHandled;
       } else if (error instanceof Response) {
         return error;
       }
@@ -54,7 +57,7 @@ async function call(handler, next, context) {
     }
   }
   if (response === null) {
-    throw RequestNotMatched;
+    throw NotMatched;
   }
   return response || next();
 }
@@ -103,8 +106,8 @@ function notMatched() {
   return null;
 }
 export {
-  RequestNotHandled,
-  RequestNotMatched,
+  NotHandled,
+  NotMatched,
   call,
   compose,
   createInput,

package/dist/runtime/router.cjs

@@ -20,9 +20,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/runtime/router.ts
 var router_exports = {};
 __export(router_exports, {
-  invokeRoute: () => invokeRoute,
-  matchRoute: () => matchRoute,
-  router: () => router
+  fetch: () => fetch,
+  invoke: () => invoke,
+  match: () => match
 });
 module.exports = __toCommonJS(router_exports);
 function notImplemented() {
@@ -30,12 +30,12 @@ function notImplemented() {
     "This should have been replaced by the @marko/run plugin at build/dev time"
   );
 }
-var router = notImplemented;
-var matchRoute = notImplemented;
-var invokeRoute = notImplemented;
+var fetch = notImplemented;
+var match = notImplemented;
+var invoke = notImplemented;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  invokeRoute,
-  matchRoute,
-  router
+  fetch,
+  invoke,
+  match
 });

package/dist/runtime/router.d.ts

@@ -1,4 +1,3 @@
-import type { MatchRoute, RequestContext, Route } from "./types";
-export declare const router: <T>(context: RequestContext<T>) => Promise<Response | void>;
-export declare const matchRoute: MatchRoute;
-export declare const invokeRoute: <T>(route: Route | null, context: RequestContext<T>) => Promise<Response | void>;
+export declare const fetch: <Platform = unknown>(request: Request, platform: Platform) => Promise<void | Response>;
+export declare const match: (method: string, pathname: string) => import("./types").RouteWithHandler<{}, unknown, string> | null;
+export declare const invoke: <Platform = unknown>(route: import("./types").RouteWithHandler<{}, unknown, string> | null, request: Request, platform: Platform) => Promise<void | Response>;

package/dist/runtime/router.js

@@ -4,11 +4,11 @@ function notImplemented() {
     "This should have been replaced by the @marko/run plugin at build/dev time"
   );
 }
-var router = notImplemented;
-var matchRoute = notImplemented;
-var invokeRoute = notImplemented;
+var fetch = notImplemented;
+var match = notImplemented;
+var invoke = notImplemented;
 export {
-  invokeRoute,
-  matchRoute,
-  router
+  fetch,
+  invoke,
+  match
 };

package/dist/runtime/types.d.ts

@@ -7,20 +7,17 @@ export interface RouteContextExtensions {
 }
 export declare type ParamsObject = Record<string, string>;
 export declare type InputObject = Record<PropertyKey, any>;
-export interface RequestContext<T = unknown> {
+export declare type RouteContext<Platform = unknown, TRoute extends Route = Route> = TRoute extends any ? Combine<RouteContextExtensions & Readonly<{
     url: URL;
-    method: string;
     request: Request;
-    platform: T;
-}
-export declare type RouteContext<TRoute extends Route = Route> = TRoute extends any ? Combine<RouteContextExtensions & Readonly<RequestContext & {
     route: TRoute["path"];
     params: TRoute["params"];
     meta: TRoute["meta"];
+    platform: Platform;
 }>> : never;
 export declare type NextFunction = () => Awaitable<Response>;
 export declare type HandlerLike<TRoute extends Route = Route> = Awaitable<OneOrMany<RouteHandler<TRoute>>>;
-export declare type RouteHandler<TRoute extends Route = Route> = (context: RouteContext<TRoute>, next: NextFunction) => Awaitable<Response | null | void>;
+export declare type RouteHandler<TRoute extends Route = Route> = (context: RouteContext<unknown, TRoute>, next: NextFunction) => Awaitable<Response | null | void>;
 export interface Route<Params extends ParamsObject = {}, Meta = unknown, Path extends string = string> {
     path: Path;
     params: Params;
@@ -29,9 +26,14 @@ export interface Route<Params extends ParamsObject = {}, Meta = unknown, Path ex
 export interface RouteWithHandler<Params extends ParamsObject = {}, Meta = unknown, Path extends string = string> extends Route<Params, Meta, Path> {
     handler: RouteHandler<this>;
 }
-export declare type MatchRoute = (method: string, pathname: string) => RouteWithHandler | null;
-export declare type Router<T = unknown> = (context: RequestContext<T>) => Promise<Response | void>;
-export declare type InvokeRoute<T = unknown> = (route: Route | null, context: RequestContext<T>) => Promise<Response | void>;
+export declare type Fetch<Platform = unknown> = (request: Request, platform: Platform) => Promise<Response | void>;
+export declare type Match = (method: string, pathname: string) => RouteWithHandler | null;
+export declare type Invoke = <Platform = unknown>(route: RouteWithHandler | null, request: Request, platform: Platform) => Promise<Response | void>;
+export interface RuntimeModule {
+    fetch: <Platform = unknown>(request: Request, platform: Platform) => Promise<Response | void>;
+    match: (method: string, pathname: string) => RouteWithHandler | null;
+    invoke: <Platform = unknown>(route: RouteWithHandler | null, request: Request, platform: Platform) => Promise<Response | void>;
+}
 declare type Member<T, U> = T extends T ? (U extends T ? T : never) : never;
 declare type Segments<T extends string, Acc extends string[] = []> = T extends "" ? Acc : T extends `${infer Left}/${infer Rest}` ? Segments<Rest, [...Acc, Left]> : [...Acc, T];
 declare type GTE<A extends any[], B extends any[]> = A["length"] extends B["length"] ? 1 : A extends [infer _Ha, ...infer Ta] ? B extends [infer _Hb, ...infer Tb] ? GTE<Ta, Tb> : 1 : 0;

package/dist/vite/codegen/index.d.ts

@@ -3,4 +3,4 @@ export declare function renderRouteTemplate(route: Route): string;
 export declare function renderRouteEntry(route: Route): string;
 export declare function renderRouter(routes: BuiltRoutes, options?: RouterOptions): string;
 export declare function renderMiddleware(middleware: RoutableFile[]): string;
-export declare function renderRouteTypeInfo(routes: BuiltRoutes, pathPrefix?: string): string;
+export declare function renderRouteTypeInfo(routes: BuiltRoutes, pathPrefix?: string, adapterTypes?: string): string;