evikit 1.0.0

package/server.js

@@ -0,0 +1,429 @@
+import { Busboy } from "@fastify/busboy";
+import { toJsonSchema } from "@valibot/to-json-schema";
+import acceptLanguage from "accept-language";
+import { po } from "gettext-parser";
+import groupBy from "lodash/groupBy.js";
+import { readFile } from "node:fs/promises";
+import { Fragment, h } from "preact";
+import { renderToString } from "preact-render-to-string";
+import {
+  object,
+  optional,
+  parse,
+  picklist,
+  record,
+  string,
+  union,
+  ValiError,
+} from "valibot";
+
+import { Po } from "./i18n.js";
+
+/** @type {import("./server-generic.js").ServerEndpoint} */
+export function endpoint({ input, outputs }, handler) {
+  const schema = union(
+    Object.entries(outputs).map(([status, schema]) =>
+      object({
+        contentType: optional(string()),
+        cookies: optional(record(string(), object({ value: string() }))),
+        headers: optional(record(string(), string())),
+        output: schema,
+        status: picklist([Number(status)]),
+      }),
+    ),
+  );
+  return {
+    handler: async (req, res) => {
+      try {
+        /** @type {Record<string, string | string[]>} */
+        const body = {};
+        if (req.headers["content-type"]) {
+          const busboy = new Busboy({
+            headers: /** @type {any} */ (req.headers),
+          });
+          busboy.on("field", (name, value) => {
+            body[name] =
+              typeof body[name] == "undefined"
+                ? value
+                : [
+                    ...(typeof body[name] == "string"
+                      ? [body[name]]
+                      : body[name]),
+                    value,
+                  ];
+          });
+          await new Promise((resolve, reject) => {
+            busboy.on("error", reject).on("finish", resolve);
+            req.pipe(busboy);
+          });
+        }
+
+        const { contentType, cookies, headers, output, status } = parse(
+          schema,
+          await handler({
+            input: parse(input, {
+              ...(req.headers.cookie
+                ? Object.fromEntries(
+                    req.headers.cookie
+                      .split("; ")
+                      .map((row) => row.split("=").map(decodeURIComponent)),
+                  )
+                : undefined),
+              ...Object.fromEntries(
+                Object.entries(
+                  groupBy(
+                    [
+                      ...new URL(
+                        `http://${req.headers.host}${req.url}`,
+                      ).searchParams.entries(),
+                    ],
+                    ([name]) => name || "",
+                  ),
+                ).map(([name, group]) => {
+                  const values = group.map((value) => value[1]);
+                  return [name, values.length == 1 ? values[0] : values];
+                }),
+              ),
+              ...body,
+            }),
+          }),
+        );
+
+        const location = headers
+          ? Object.entries(headers).find(
+              ([name]) => name.toLowerCase() == "location",
+            )?.[1]
+          : undefined;
+        const opaqueRedirectWorkaround =
+          req.headers.accept == "application/json" && location
+            ? { location, status }
+            : undefined;
+        const workaroundHeaders = headers
+          ? Object.entries(headers).filter(([name]) => {
+              const lower = name.toLowerCase();
+              return (
+                lower != "content-type" &&
+                (lower != "location" || !opaqueRedirectWorkaround)
+              );
+            })
+          : [];
+
+        if (cookies) {
+          workaroundHeaders.push([
+            "set-cookie",
+            Object.entries(cookies || "")
+              .map(
+                ([name, { value }]) =>
+                  `${encodeURIComponent(name)}=${encodeURIComponent(value)}`,
+              )
+              .join("; "),
+          ]);
+        }
+
+        if (contentType == "application/json") {
+          res.statusCode = status;
+          res.setHeader("content-type", "application/json; charset=utf-8");
+          for (const [name, value] of workaroundHeaders) {
+            res.setHeader(name, value);
+          }
+          res.end(JSON.stringify(output));
+        } else if (opaqueRedirectWorkaround) {
+          res.setHeader("content-type", "application/json; charset=utf-8");
+          for (const [name, value] of workaroundHeaders) {
+            res.setHeader(name, value);
+          }
+          res.end(JSON.stringify({ opaqueRedirectWorkaround }));
+        } else {
+          res.statusCode = status;
+          res.setHeader("content-type", "text/plain; charset=utf-8");
+          for (const [name, value] of workaroundHeaders) {
+            res.setHeader(name, value);
+          }
+          res.end(output);
+        }
+      } catch (/** @type {any} */ error) {
+        console.error(error);
+        res.statusCode = error instanceof ValiError ? 400 : 500;
+        res.setHeader("content-type", "text/plain; charset=utf-8");
+        res.end(error.message);
+      }
+    },
+    input,
+    outputs,
+  };
+}
+
+/** @type {import("./server-generic.js").ServerJson} */
+export function json(output) {
+  return {
+    contentType: /** @type {any} */ ("application/json"),
+    output,
+    status: 200,
+  };
+}
+
+/** @param {{ listen: (port: number, callback: () => void) => { close(): void, on(event: "error", callback: (error: unknown) => void ): void } }} app */
+export function listen(app) {
+  const port = Number(process.env["PORT"]) || 5173;
+  const server = app.listen(port, () => {
+    console.log(
+      `Server started at ${process.env["ORIGIN"] || `http://localhost:${port}`}`,
+    );
+  });
+  server.on("error", (error) => {
+    console.error(error);
+    process.exitCode = 1;
+  });
+  process.on("SIGTERM", () => {
+    server.close();
+  });
+}
+
+/** @param {{ html: string, prerender({ lang, url }: { lang: string, url: string }): Promise<{ data: {}, head: { elements: Set<{ props: { [k: string]: string }, type: string }>, lang: string, title: string }, html: string }> }} props */
+export function production({ html, prerender }) {
+  /**
+   * @param {import("node:http").IncomingMessage} req
+   * @param {import("node:http").ServerResponse<import("node:http").IncomingMessage>} res
+   */
+  return async function onRequest(req, res) {
+    try {
+      const rendered = await prerender({
+        lang: acceptLanguage.get(req.headers["accept-language"]) || "en",
+        url: req.url || "/",
+      });
+      res.statusCode =
+        // https://indieweb.org/meta_http-equiv_status
+        Number(
+          [...rendered.head.elements.values()]
+            .find(
+              ({ props, type }) =>
+                type == "meta" && props["http-equiv"] == "status",
+            )
+            ?.props["content"]?.replace(/ .*/, ""),
+        ) || 200;
+      res.setHeader("content-type", "text/html; charset=utf-8");
+      res.end(
+        html
+          .replace(/lang=".+?"/, () => `lang="${rendered.head.lang}"`)
+          .replace(/<title>.+<\/title>/, () =>
+            renderToString(h("title", null, rendered.head.title)),
+          )
+          .replace(/<meta http-equiv="status" content=".+?">/, "")
+          .replace(
+            `<!--app-head-->`,
+            renderToString(
+              h(
+                Fragment,
+                null,
+                [...rendered.head.elements.values()].map(({ props, type }) =>
+                  h(type, props),
+                ),
+              ),
+            ),
+          )
+          .replace(
+            /(<div id="app">)[\s\S]+<!--app-html-->/,
+            (_, div) =>
+              div +
+              rendered.html +
+              '<script type="application/json" id="preact-prerender-data">' +
+              JSON.stringify(rendered.data).replace(/\//g, "\\/") +
+              "</script>",
+          ),
+      );
+    } catch (error) {
+      console.error(error);
+      res.statusCode = 500;
+      res.end("Internal Server Error");
+    }
+  };
+}
+
+/** @type {import("./server-generic.js").ServerRedirect} */
+export function redirect(location, status, init) {
+  return {
+    contentType: /** @type {any} */ ("text/plain"),
+    cookies: init?.cookies,
+    headers: { location },
+    output: location,
+    status,
+  };
+}
+
+/**
+ * @param {string} path
+ * @param {import("./server-generic.js").MethodServer} controller */
+export function route(path, controller) {
+  return { controller, path, pattern: new URLPattern(`http://*:*${path}`) };
+}
+
+/**
+ * @param {{ pkg: { name: string, version: string } }} props
+ * @param {ReturnType<typeof route>[]} routes
+ */
+export function router({ pkg }, ...routes) {
+  const openapi = {
+    info: { title: pkg.name, version: pkg.version },
+    openapi: "3.1.0",
+    paths: Object.fromEntries(
+      Object.values(routes).map(({ controller, path }) => [
+        path.replace(/:(\w+)/g, "{$1}"),
+        Object.fromEntries(
+          Object.entries(controller).map(([method, { input, outputs }]) => {
+            const parameters = path
+              .split("/")
+              .filter((component) => /^:/.test(component))
+              .map((component) => component.slice(1));
+            return [
+              method,
+              {
+                parameters: parameters.map((name) => ({
+                  in: "path",
+                  name,
+                  required: true,
+                  schema: { type: "string" },
+                })),
+                ...(method == "post"
+                  ? {
+                      requestBody: {
+                        content: {
+                          "application/x-www-form-urlencoded": {
+                            schema: toJsonSchema(
+                              object(
+                                Object.fromEntries(
+                                  Object.entries(input.entries).filter(
+                                    ([name]) => !parameters.includes(name),
+                                  ),
+                                ),
+                              ),
+                              { ignoreActions: ["trim"] },
+                            ),
+                          },
+                        },
+                      },
+                    }
+                  : undefined),
+                responses: Object.fromEntries(
+                  Object.entries(outputs).map(([status, schema]) => [
+                    status,
+                    {
+                      content: {
+                        ["application/json"]: { schema: toJsonSchema(schema) },
+                      },
+                      description:
+                        status == "200"
+                          ? "OK"
+                          : status == "302"
+                            ? "Found"
+                            : "Bad Request",
+                    },
+                  ]),
+                ),
+              },
+            ];
+          }),
+        ),
+      ]),
+    ),
+    servers: [{ url: process.env["ORIGIN"] || "" }],
+  };
+
+  Po.set(async (lang) =>
+    po.parse(await readFile(`po/${encodeURIComponent(lang)}.po`, "utf-8")),
+  );
+
+  const poPattern = new URLPattern(`http://*:*/po/:lang`);
+
+  /**
+   * @param {import("node:http").IncomingMessage} req
+   * @param {import("node:http").ServerResponse<import("node:http").IncomingMessage>} res
+   * @param {() => void} [next]
+   */
+  async function onRequest(req, res, next) {
+    const lowercase = req.method?.toLowerCase();
+    const url = new URL(`http://${req.headers.host}${req.url}`);
+
+    const pathname = poPattern.exec(url)?.pathname;
+    if (pathname) {
+      const lang = acceptLanguage.get(pathname.groups["lang"]) || "en";
+      if (lang != "en") {
+        res.setHeader("content-type", "application/json");
+        res.end(JSON.stringify(await Po.get(lang)));
+        return;
+      }
+    }
+
+    for (const { controller, pattern } of Object.values(routes)) {
+      const pathname = pattern.exec(url)?.pathname;
+      if (pathname) {
+        for (const [method, { handler }] of Object.entries(controller)) {
+          if (method == lowercase) {
+            const lang =
+              acceptLanguage.get(req.headers["accept-language"]) || "en";
+            if (!url.searchParams.has(lang)) {
+              url.searchParams.set("lang", lang);
+            }
+            for (const [name, value] of Object.entries(pathname.groups)) {
+              if (!url.searchParams.has(name)) {
+                url.searchParams.set(name, value || "");
+              }
+            }
+            req.url = url.pathname + (url.search || "");
+            handler(req, res);
+            return;
+          }
+        }
+
+        if (lowercase == "options") {
+          res.statusCode = 204;
+          res.setHeader(
+            "allow",
+            [
+              ...new Set([
+                "OPTIONS",
+                ...Object.keys(controller).map((x) => x.toUpperCase()),
+              ]),
+            ].join(", "),
+          );
+          res.end();
+          return;
+        }
+
+        res.statusCode = 405;
+        res.end("Method Not Allowed");
+        return;
+      }
+    }
+
+    if (req.url == "/api" || req.url?.startsWith("/api/")) {
+      res.statusCode = 404;
+      res.end("Not Found");
+      return;
+    }
+
+    if (req.url == "/openapi.json") {
+      res.setHeader("content-type", "application/json");
+      res.end(JSON.stringify(openapi));
+      return;
+    }
+
+    if (!next) {
+      res.statusCode = 404;
+      res.end("Not Found");
+      return;
+    }
+
+    next();
+  }
+
+  return { onRequest, openapi };
+}
+
+/** @type {import("./server-generic.js").ServerText} */
+export function text(output, status) {
+  return {
+    contentType: /** @type {any} */ ("text/plain"),
+    output,
+    status,
+  };
+}

package/sqlite.d.ts

@@ -0,0 +1,8 @@
+import type { ObjectSchema } from "valibot";
+
+import type { Db } from "./db.d.ts";
+
+export function sqlite<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Schema extends Record<string, ObjectSchema<any, any>>,
+>(path: string, { schema }: { schema: Schema }): Db<Schema>;