@hyperspan/framework 2.0.0 → 2.0.1

package/dist/server.js

@@ -0,0 +1,580 @@
+var __freeze = Object.freeze;
+var __defProp = Object.defineProperty;
+var __template = (cooked, raw) => __freeze(__defProp(cooked, "raw", { value: __freeze(raw || cooked.slice()) }));
+var _a;
+import "./ssr/install-server-dom-mock.js";
+import { html, isHSHtml, renderStream, renderAsync, render, _typeOf } from "./html.js";
+import { isbot } from "isbot";
+import { executeMiddleware } from "./middleware.js";
+import { buildUrl, parsePath, removeUndefined } from "./utils.js";
+import { Cookies } from "./cookies.js";
+import { nodeAdapter } from "@hyperspan/adapter-node";
+const IS_PROD = process.env.NODE_ENV === "production";
+function hyperspanDisableStreaming(context) {
+  return isbot(context.req.raw.headers.get("user-agent") ?? "");
+}
+const disableStreamingOptions = { hyperspanDisableStreaming };
+function shouldDisableStreaming(disableStreaming, context) {
+  return disableStreaming?.(context, disableStreamingOptions) ?? false;
+}
+class HTTPResponseException extends Error {
+  _error;
+  _response;
+  constructor(body, options) {
+    super(body instanceof Error ? body.message : body);
+    this._error = body instanceof Error ? body : void 0;
+    this._response = new Response(body instanceof Error ? body.message : body, options);
+  }
+}
+function createConfig(config = {}) {
+  const defaultConfig = {
+    appDir: "./app",
+    publicDir: "./public",
+    plugins: [],
+    deployAdapter: config.deployAdapter ?? nodeAdapter(),
+    responseOptions: {
+      disableStreaming: hyperspanDisableStreaming
+    }
+  };
+  return {
+    ...defaultConfig,
+    ...config,
+    deployAdapter: config.deployAdapter ?? defaultConfig.deployAdapter,
+    responseOptions: {
+      ...defaultConfig.responseOptions,
+      ...config.responseOptions
+    }
+  };
+}
+function createContext(req, route) {
+  const url = new URL(req.url);
+  const query = new URLSearchParams(url.search);
+  const method = req.method.toUpperCase();
+  const requestHeaders = new Headers(req.headers);
+  const responseHeaders = new Headers();
+  const path = route?._path() || "/";
+  const requestParams = req.params;
+  const params = Object.assign(
+    {},
+    requestParams || {},
+    removeUndefined(route?._config.params || {})
+  );
+  const catchAllParam = Object.keys(params).find((key) => key.startsWith("..."));
+  if (catchAllParam && path.includes("/*")) {
+    const catchAllValue = url.pathname.split(path.replace("/*", "/")).pop();
+    params[catchAllParam.replace("...", "")] = catchAllValue;
+    delete params[catchAllParam];
+  }
+  let status = void 0;
+  const copyHeaders = (source, target) => {
+    source.forEach((value, key) => {
+      if (key.toLowerCase() === "set-cookie") return;
+      target.set(key, value);
+    });
+    const cookies = typeof source.getSetCookie === "function" ? source.getSetCookie() : [];
+    for (const cookie of cookies) {
+      target.append("Set-Cookie", cookie);
+    }
+  };
+  const merge = async (response) => {
+    const mergedHeaders = new Headers();
+    copyHeaders(responseHeaders, mergedHeaders);
+    copyHeaders(response.headers, mergedHeaders);
+    return new Response(await response.text(), {
+      status: context.res.status ?? response.status,
+      headers: mergedHeaders
+    });
+  };
+  const context = {
+    vars: {},
+    url: (diff, options) => {
+      const next = buildUrl(url, diff, options);
+      return `${next.pathname}${next.search}${next.hash}`;
+    },
+    route: {
+      name: route?._config.name || void 0,
+      path,
+      params,
+      cssImports: route ? route._config.cssImports ?? [] : []
+    },
+    req: {
+      raw: req,
+      url,
+      method,
+      headers: requestHeaders,
+      query,
+      cookies: new Cookies(req),
+      async text() {
+        return req.clone().text();
+      },
+      async json() {
+        return await req.clone().json();
+      },
+      async formData() {
+        return await req.clone().formData();
+      },
+      async urlencoded() {
+        return new URLSearchParams(await req.clone().text());
+      }
+    },
+    res: {
+      cookies: new Cookies(req, responseHeaders),
+      headers: responseHeaders,
+      status,
+      html: (html2, options) => merge(
+        new Response(html2, {
+          ...options,
+          headers: { "Content-Type": "text/html; charset=UTF-8", ...options?.headers }
+        })
+      ),
+      json: (json, options) => merge(
+        new Response(JSON.stringify(json), {
+          ...options,
+          headers: { "Content-Type": "application/json", ...options?.headers }
+        })
+      ),
+      text: (text, options) => merge(
+        new Response(text, {
+          ...options,
+          headers: { "Content-Type": "text/plain; charset=UTF-8", ...options?.headers }
+        })
+      ),
+      redirect: (url2, options) => merge(new Response(null, { status: 302, headers: { Location: url2, ...options?.headers } })),
+      error: (error, options) => merge(new Response(error.message, { status: 500, ...options })),
+      notFound: (options) => merge(new Response("Not Found", { status: 404, ...options })),
+      merge
+    }
+  };
+  return context;
+}
+function noContentResponse(context) {
+  return new Response(null, {
+    status: 204,
+    headers: context.res.headers
+  });
+}
+function createRoute(config = {}) {
+  const _handlers = {};
+  let _errorHandler = void 0;
+  const api = {
+    _kind: "hsRoute",
+    _config: config,
+    _middleware: {
+      GET: [],
+      POST: [],
+      PUT: [],
+      PATCH: [],
+      DELETE: [],
+      HEAD: [],
+      OPTIONS: [],
+      "*": []
+    },
+    _methods: () => Object.keys(_handlers),
+    _path() {
+      if (this._config.path) {
+        const { path } = parsePath(this._config.path);
+        return path;
+      }
+      return "/";
+    },
+    /**
+     * Add a GET route handler (primary page display)
+     */
+    get(handler, handlerOptions) {
+      _handlers["GET"] = handler;
+      api._middleware["GET"] = handlerOptions?.middleware || [];
+      return api;
+    },
+    /**
+     * Add a POST route handler (typically to process form data)
+     */
+    post(handler, handlerOptions) {
+      _handlers["POST"] = handler;
+      api._middleware["POST"] = handlerOptions?.middleware || [];
+      return api;
+    },
+    /**
+     * Add a PUT route handler (typically to update existing data)
+     */
+    put(handler, handlerOptions) {
+      _handlers["PUT"] = handler;
+      api._middleware["PUT"] = handlerOptions?.middleware || [];
+      return api;
+    },
+    /**
+     * Add a PATCH route handler (typically to update existing data)
+     */
+    patch(handler, handlerOptions) {
+      _handlers["PATCH"] = handler;
+      api._middleware["PATCH"] = handlerOptions?.middleware || [];
+      return api;
+    },
+    /**
+     * Add a DELETE route handler (typically to delete existing data)
+     */
+    delete(handler, handlerOptions) {
+      _handlers["DELETE"] = handler;
+      api._middleware["DELETE"] = handlerOptions?.middleware || [];
+      return api;
+    },
+    /**
+     * Add a OPTIONS route handler (typically to handle CORS preflight requests)
+     */
+    options(handler, handlerOptions) {
+      _handlers["OPTIONS"] = handler;
+      api._middleware["OPTIONS"] = handlerOptions?.middleware || [];
+      return api;
+    },
+    /**
+     * Add a ALL route handler (typically to handle all HTTP methods)
+     */
+    all(handler, handlerOptions) {
+      _handlers["*"] = handler;
+      api._middleware["*"] = handlerOptions?.middleware || [];
+      return api;
+    },
+    /**
+     * Set a custom error handler for this route to fall back to if the route handler throws an error
+     */
+    errorHandler(handler) {
+      _errorHandler = handler;
+      return api;
+    },
+    /**
+     * Add a middleware function to this route (for all HTTP methods) (non-destructive)
+     */
+    use(middleware, opts = {}) {
+      if (opts?.methods) {
+        opts.methods.forEach((method) => {
+          api._middleware[method].push(middleware);
+        });
+      } else {
+        api._middleware["*"].push(middleware);
+      }
+      return api;
+    },
+    /**
+     * Set the complete middleware stack for this route (for all HTTP methods) (destructive)
+     * NOTE: This will override the middleware stack for this route
+     */
+    middleware(middleware, opts = {}) {
+      if (opts?.methods) {
+        opts.methods.forEach((method) => {
+          api._middleware[method] = middleware;
+        });
+      } else {
+        api._middleware["*"] = middleware;
+      }
+      return api;
+    },
+    /**
+     * Fetch - handle a direct HTTP request
+     */
+    async fetch(request) {
+      const context = createContext(request, api);
+      const method = context.req.method;
+      const globalMiddleware = api._middleware["*"] || [];
+      const methodMiddleware = api._middleware[method] || [];
+      const methodHandler = async (context2) => {
+        if (method === "OPTIONS" && !_handlers["OPTIONS"]) {
+          return context2.res.html(
+            render(html`
+              <!DOCTYPE html>
+              <html lang="en"></html>
+            `),
+            {
+              status: 200,
+              headers: {
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": ["HEAD", "OPTIONS", ...Object.keys(_handlers)].join(
+                  ", "
+                ),
+                "Access-Control-Allow-Headers": "Content-Type, Authorization"
+              }
+            }
+          );
+        }
+        const handler = (method === "HEAD" ? _handlers["GET"] : _handlers[method]) ?? _handlers["*"];
+        if (!handler) {
+          return context2.res.error(new Error("Method not allowed"), { status: 405 });
+        }
+        let routeContent;
+        try {
+          routeContent = await handler(context2);
+        } catch (e) {
+          if (e instanceof HTTPResponseException) {
+            routeContent = e._response;
+          } else {
+            throw e;
+          }
+        }
+        if (routeContent instanceof Response) {
+          return routeContent;
+        }
+        if (isHTMLContent(routeContent)) {
+          const responseOptions = {
+            ...api._serverConfig?.responseOptions ?? {},
+            ...api._config?.responseOptions ?? {}
+          };
+          return returnHTMLResponse(context2, () => routeContent, responseOptions);
+        }
+        const streamOptions = {
+          status: context2.res.status ?? 200,
+          headers: Object.fromEntries(context2.res.headers.entries())
+        };
+        const contentType = _typeOf(routeContent);
+        if (contentType === "generator") {
+          return new StreamResponse(routeContent, streamOptions);
+        }
+        if (routeContent instanceof ReadableStream) {
+          return new StreamResponse(routeContent, streamOptions);
+        }
+        if (routeContent === void 0 || routeContent === null) {
+          return noContentResponse(context2);
+        }
+        return routeContent;
+      };
+      try {
+        return await executeMiddleware(context, [
+          ...globalMiddleware,
+          ...methodMiddleware,
+          methodHandler
+        ]);
+      } catch (e) {
+        if (_errorHandler !== void 0) {
+          const responseOptions = {
+            ...api._serverConfig?.responseOptions ?? {},
+            ...api._config?.responseOptions ?? {}
+          };
+          return returnHTMLResponse(
+            context,
+            () => _errorHandler(context, e),
+            responseOptions
+          );
+        }
+        throw e;
+      }
+    }
+  };
+  return api;
+}
+async function createServer(config = {}) {
+  const _routes = [];
+  if (config.plugins && config.plugins.length > 0) {
+    await Promise.all(config.plugins.map((plugin) => plugin(config)));
+  }
+  const api = {
+    _config: config,
+    _routes,
+    _middleware: {
+      GET: [],
+      POST: [],
+      PUT: [],
+      PATCH: [],
+      DELETE: [],
+      HEAD: [],
+      OPTIONS: [],
+      "*": []
+    },
+    use(middleware, opts) {
+      if (opts?.methods) {
+        opts.methods.forEach((method) => {
+          api._middleware[method].push(middleware);
+        });
+      } else {
+        api._middleware["*"].push(middleware);
+      }
+      return this;
+    },
+    get(path, handler, handlerOptions) {
+      const route = createRoute().get(handler, handlerOptions);
+      route._config.path = path;
+      _routes.push(route);
+      return route;
+    },
+    post(path, handler, handlerOptions) {
+      const route = createRoute().post(handler, handlerOptions);
+      route._config.path = path;
+      _routes.push(route);
+      return route;
+    },
+    put(path, handler, handlerOptions) {
+      const route = createRoute().put(handler, handlerOptions);
+      route._config.path = path;
+      _routes.push(route);
+      return route;
+    },
+    delete(path, handler, handlerOptions) {
+      const route = createRoute().delete(handler, handlerOptions);
+      route._config.path = path;
+      _routes.push(route);
+      return route;
+    },
+    patch(path, handler, handlerOptions) {
+      const route = createRoute().patch(handler, handlerOptions);
+      route._config.path = path;
+      _routes.push(route);
+      return route;
+    },
+    options(path, handler, handlerOptions) {
+      const route = createRoute().options(handler, handlerOptions);
+      route._config.path = path;
+      _routes.push(route);
+      return route;
+    },
+    all(path, handler, handlerOptions) {
+      const route = createRoute().all(handler, handlerOptions);
+      route._config.path = path;
+      _routes.push(route);
+      return route;
+    }
+  };
+  return api;
+}
+async function initServerRoutes(server, config, addRoutes) {
+  await config.beforeRoutesAdded?.(server);
+  await addRoutes(server);
+  await config.afterRoutesAdded?.(server);
+}
+function isHTMLContent(response) {
+  const hasHTMLContentType = response instanceof Response && response.headers.get("Content-Type") === "text/html";
+  const isHTMLTemplate = isHSHtml(response);
+  const isHTMLString = typeof response === "string" && response.trim().startsWith("<");
+  return hasHTMLContentType || isHTMLTemplate || isHTMLString;
+}
+async function returnHTMLResponse(context, handlerFn, responseOptions) {
+  try {
+    const routeContent = await handlerFn();
+    if (routeContent instanceof Response) {
+      return routeContent;
+    }
+    if (isHSHtml(routeContent)) {
+      const disableStreaming = shouldDisableStreaming(responseOptions?.disableStreaming, context);
+      if (!disableStreaming && routeContent.asyncContent?.length > 0) {
+        return new StreamResponse(
+          renderStream(routeContent, {
+            renderChunk: (chunk) => {
+              return html(_a || (_a = __template(['\n                <template id="', '_content">', "<!--end--></template>\n                <script>\n                  window._hsc = window._hsc || [];\n                  window._hsc.push({ id: '", "' });\n                <\/script>\n                <!--/hs:chunk-->\n              "])), chunk.id, html.raw(chunk.content), chunk.id);
+            }
+          }),
+          responseOptions
+        );
+      } else {
+        const output = await renderAsync(routeContent);
+        return context.res.html(output, responseOptions);
+      }
+    }
+    return context.res.html(String(routeContent), responseOptions);
+  } catch (e) {
+    !IS_PROD && console.error(e);
+    return await showErrorReponse(context, e, responseOptions);
+  }
+}
+function getRunnableRoute(route, routeConfig) {
+  if (isRunnableRoute(route)) {
+    return route;
+  }
+  const kind = typeof route;
+  if (kind === "object" && "default" in route) {
+    return getRunnableRoute(route.default, routeConfig);
+  }
+  throw new Error(
+    `Route not runnable. Use "export default createRoute()" to create a Hyperspan route. Exported methods found were: ${Object.keys(route).join(", ")}`
+  );
+}
+function isRunnableRoute(route) {
+  if (typeof route !== "object") {
+    return false;
+  }
+  const obj = route;
+  return typeof obj?._kind === "string" && "fetch" in obj;
+}
+async function showErrorReponse(context, err, responseOptions) {
+  let status = 500;
+  const message = err.message || "Internal Server Error";
+  if (err instanceof HTTPResponseException) {
+    status = err._response?.status ?? 500;
+  }
+  const stack = !IS_PROD && err.stack ? err.stack.split("\n").slice(1).join("\n") : "";
+  if (context.req.headers.get("X-Request-Type") === "partial") {
+    const output2 = render(html`
+      <section style="padding: 20px;">
+        <p style="margin-bottom: 10px;"><strong>Error</strong></p>
+        <strong>${message}</strong>
+        ${stack ? html`<pre>${stack}</pre>` : ""}
+      </section>
+    `);
+    return context.res.html(output2, Object.assign({ status }, responseOptions));
+  }
+  const output = render(html`
+    <!DOCTYPE html>
+    <html lang="en">
+      <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>Application Error</title>
+      </head>
+      <body>
+        <main>
+          <h1>Application Error</h1>
+          <strong>${message}</strong>
+          ${stack ? html`<pre>${stack}</pre>` : ""}
+        </main>
+      </body>
+    </html>
+  `);
+  return context.res.html(output, Object.assign({ status }, responseOptions));
+}
+class StreamResponse extends Response {
+  constructor(body, options = {}) {
+    super();
+    const { status, headers, ...restOptions } = options;
+    const stream = body instanceof ReadableStream ? body : createReadableStreamFromAsyncGenerator(body);
+    const defaultContentType = body instanceof ReadableStream ? "application/octet-stream" : "text/html; charset=UTF-8";
+    const mergedHeaders = new Headers({
+      "Transfer-Encoding": "chunked",
+      "Content-Type": defaultContentType,
+      "Content-Encoding": "Identity"
+    });
+    if (headers) {
+      for (const [key, value] of Object.entries(headers)) {
+        mergedHeaders.set(key, value);
+      }
+    }
+    return new Response(stream, {
+      status: status ?? 200,
+      headers: mergedHeaders,
+      ...restOptions
+    });
+  }
+}
+function createReadableStreamFromAsyncGenerator(output) {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    async start(controller) {
+      while (true) {
+        const { done, value } = await output.next();
+        if (done) {
+          controller.close();
+          break;
+        }
+        controller.enqueue(encoder.encode(value));
+      }
+    }
+  });
+}
+export {
+  HTTPResponseException,
+  IS_PROD,
+  StreamResponse,
+  createConfig,
+  createContext,
+  createReadableStreamFromAsyncGenerator,
+  createRoute,
+  createServer,
+  getRunnableRoute,
+  hyperspanDisableStreaming,
+  initServerRoutes,
+  isRunnableRoute,
+  returnHTMLResponse
+};

package/dist/ssr/install-server-dom-mock.js

@@ -0,0 +1,2 @@
+import { installMockDom } from "./mock-dom.js";
+installMockDom();