evikit 2.11.1 → 2.13.0

package/db.js

@@ -1,128 +1,128 @@
-import { getMetadata, metadata } from "valibot";
-
-/** @type {typeof import('./db.d.ts').flatten} */
-export function flatten(relations) {
-  return /** @type {any} */ (
-    Object.fromEntries(
-      Object.entries(relations).map(([Self, self]) => [
-        Self,
-        Object.fromEntries(
-          Object.values(self)
-            .map((own) =>
-              Object.values(own).map((other) =>
-                Object.values(other).map((its) => [its.name, its]),
-              ),
-            )
-            .flat()
-            .flat(),
-        ),
-      ]),
-    )
-  );
-}
-
-export function primary() {
-  return metadata({ primary: true });
-}
-
-/** @type {typeof import('./db.d.ts').references} */
-export function references(references, key) {
-  return metadata({ key: references.entries[key], references });
-}
-
-/** @type {typeof import('./db.d.ts').relations} */
-export function relations(schema) {
-  return /** @type {any} */ (
-    Object.fromEntries(
-      Object.entries(/** @type {any} */ (schema)).map(([Self, self]) => [
-        Self,
-        Object.fromEntries(
-          Object.entries(self.entries)
-            .map(([Own, own]) => [
-              Own,
-              Object.fromEntries(
-                Object.entries(/** @type {any} */ (schema))
-                  .map(([Other, other]) => [
-                    Other,
-                    Object.fromEntries(
-                      Object.entries(other.entries)
-                        .map(([Its, its]) => {
-                          const ownMetadata =
-                            /** @type {{ key?: string, references: any }} */ (
-                              getMetadata(own)
-                            );
-
-                          const itsMetadata =
-                            /** @type {{ key?: string, references: any }} */ (
-                              getMetadata(its)
-                            );
-                          return [
-                            Its,
-                            ownMetadata.key == its &&
-                            other == ownMetadata.references
-                              ? {
-                                  Its: Its,
-                                  name: rewrite(Self, Own, Other, Its),
-                                  Other: Other,
-                                  Own: Own,
-                                  type: "references",
-                                }
-                              : itsMetadata.key == own &&
-                                  self == itsMetadata.references
-                                ? {
-                                    Its: Its,
-                                    name: rewrite(Self, Own, Other, Its),
-                                    Other: Other,
-                                    Own: Own,
-                                    type: "referencedBy",
-                                  }
-                                : undefined,
-                          ];
-                        })
-                        .filter(([, maybeUndefined]) => maybeUndefined),
-                    ),
-                  ])
-                  .filter(([, maybeRecordUndefined]) =>
-                    Object.values(maybeRecordUndefined).some((value) => value),
-                  ),
-              ),
-            ])
-            .filter(([, maybeRecordUndefined]) =>
-              Object.values(maybeRecordUndefined).some((value) => value),
-            ),
-        ),
-      ]),
-    )
-  );
-}
-
-/** @param {string} input */
-function capitalize(input) {
-  return `${input[0]?.toUpperCase()}${input.slice(1)}`;
-}
-
-/**
- * @param {string} Self
- * @param {string} Own
- * @param {string} Other
- * @param {string} Its
- */
-function rewrite(Self, Own, Other, Its) {
-  return (
-    // Image.id, Question.imageId -> Image.Question.
-    Its == `${uncapitalize(Self)}${capitalize(Own)}`
-      ? Other
-      : // Quiz.coverId, Image.id -> Quiz.cover.
-        Own.endsWith(capitalize(Its))
-        ? Own.slice(0, -Its.length)
-        : // Image.id, Quiz.coverId -> Image.CoverQuiz.
-          Its.endsWith(capitalize(Own))
-          ? `${capitalize(Its.slice(0, -Own.length))}${Other}`
-          : undefined
-  );
-}
-
-/** @param {string} input */
-function uncapitalize(input) {
-  return `${input[0]?.toLowerCase()}${input.slice(1)}`;
-}
+import { getMetadata, metadata } from "valibot";
+
+/** @type {typeof import('./db.d.ts').flatten} */
+export function flatten(relations) {
+  return /** @type {any} */ (
+    Object.fromEntries(
+      Object.entries(relations).map(([Self, self]) => [
+        Self,
+        Object.fromEntries(
+          Object.values(self)
+            .map((own) =>
+              Object.values(own).map((other) =>
+                Object.values(other).map((its) => [its.name, its]),
+              ),
+            )
+            .flat()
+            .flat(),
+        ),
+      ]),
+    )
+  );
+}
+
+export function primary() {
+  return metadata({ primary: true });
+}
+
+/** @type {typeof import('./db.d.ts').references} */
+export function references(references, key) {
+  return metadata({ key: references.entries[key], references });
+}
+
+/** @type {typeof import('./db.d.ts').relations} */
+export function relations(schema) {
+  return /** @type {any} */ (
+    Object.fromEntries(
+      Object.entries(/** @type {any} */ (schema)).map(([Self, self]) => [
+        Self,
+        Object.fromEntries(
+          Object.entries(self.entries)
+            .map(([Own, own]) => [
+              Own,
+              Object.fromEntries(
+                Object.entries(/** @type {any} */ (schema))
+                  .map(([Other, other]) => [
+                    Other,
+                    Object.fromEntries(
+                      Object.entries(other.entries)
+                        .map(([Its, its]) => {
+                          const ownMetadata =
+                            /** @type {{ key?: string, references: any }} */ (
+                              getMetadata(own)
+                            );
+
+                          const itsMetadata =
+                            /** @type {{ key?: string, references: any }} */ (
+                              getMetadata(its)
+                            );
+                          return [
+                            Its,
+                            ownMetadata.key == its &&
+                            other == ownMetadata.references
+                              ? {
+                                  Its: Its,
+                                  name: rewrite(Self, Own, Other, Its),
+                                  Other: Other,
+                                  Own: Own,
+                                  type: "references",
+                                }
+                              : itsMetadata.key == own &&
+                                  self == itsMetadata.references
+                                ? {
+                                    Its: Its,
+                                    name: rewrite(Self, Own, Other, Its),
+                                    Other: Other,
+                                    Own: Own,
+                                    type: "referencedBy",
+                                  }
+                                : undefined,
+                          ];
+                        })
+                        .filter(([, maybeUndefined]) => maybeUndefined),
+                    ),
+                  ])
+                  .filter(([, maybeRecordUndefined]) =>
+                    Object.values(maybeRecordUndefined).some((value) => value),
+                  ),
+              ),
+            ])
+            .filter(([, maybeRecordUndefined]) =>
+              Object.values(maybeRecordUndefined).some((value) => value),
+            ),
+        ),
+      ]),
+    )
+  );
+}
+
+/** @param {string} input */
+function capitalize(input) {
+  return `${input[0]?.toUpperCase()}${input.slice(1)}`;
+}
+
+/**
+ * @param {string} Self
+ * @param {string} Own
+ * @param {string} Other
+ * @param {string} Its
+ */
+function rewrite(Self, Own, Other, Its) {
+  return (
+    // Image.id, Question.imageId -> Image.Question.
+    Its == `${uncapitalize(Self)}${capitalize(Own)}`
+      ? Other
+      : // Quiz.coverId, Image.id -> Quiz.cover.
+        Own.endsWith(capitalize(Its))
+        ? Own.slice(0, -Its.length)
+        : // Image.id, Quiz.coverId -> Image.CoverQuiz.
+          Its.endsWith(capitalize(Own))
+          ? `${capitalize(Its.slice(0, -Own.length))}${Other}`
+          : undefined
+  );
+}
+
+/** @param {string} input */
+function uncapitalize(input) {
+  return `${input[0]?.toLowerCase()}${input.slice(1)}`;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "evikit",
   "description": "Preact/SQLite SSR framework for small web apps",
-  "version": "2.11.1",
+  "version": "2.13.0",
   "type": "module",
   "exports": {
     ".": "./index.js",
@@ -32,15 +32,22 @@
   },
   "peerDependencies": {
     "accept-language": "^3.0.20",
+    "esbuild": "^0.28.2",
     "hoofd": "^1.7.3",
     "preact": "^10.29.2",
     "preact-iso": "^2.12.0",
     "valibot": "^1.4.0"
   },
+  "peerDependenciesMeta": {
+    "esbuild": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@eslint/compat": "^2.1.0",
     "@eslint/js": "^10.0.1",
     "@types/node": "^24.13.3",
+    "esbuild": "^0.28.2",
     "eslint": "^10.4.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-perfectionist": "^5.9.0",
@@ -48,5 +55,8 @@
     "prettier": "^3.8.3",
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.59.4"
+  },
+  "allowScripts": {
+    "esbuild": true
   }
 }

package/server.d.ts

@@ -29,7 +29,7 @@ export function production({
   html,
   prerender,
 }: {
-  html: string;
+  html?: string;
   prerender({ lang, url }: { lang: string; url: string }): Promise<{
     data: object;
     head: {

package/server.js

@@ -4,7 +4,8 @@ import acceptLanguage from "accept-language";
 import { po } from "gettext-parser";
 import cluster from "node:cluster";
 import { createHash } from "node:crypto";
-import { readFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { readFile, unlink, writeFile } from "node:fs/promises";
 import { availableParallelism } from "node:os";
 import { h } from "preact";
 import { renderToString } from "preact-render-to-string";
@@ -207,10 +208,104 @@ export function json(output) {
   };
 }
 
+let esbuild = false;
+
 /** @param {{ listen: (port: number, callback: () => void) => { close(): void, on(event: "error", callback: (error: unknown) => void ): void } }} app */
-export function listen(app) {
+export async function listen(app) {
+  if (esbuild && cluster.isPrimary) {
+    let esbuildPort = 0;
+
+    async function makeHtml() {
+      await writeFile(
+        "./dist/index.html",
+        (await readFile("./index.html", "utf-8"))
+          .replace(
+            "/index.css",
+            "/index.css?" + (await sha256("./dist/index.css")),
+          )
+          .replace(
+            /<script[^>]+><\/script>/,
+            '<script src="/src/prerender.js?' +
+              (await sha256("./dist/src/prerender.js")) +
+              '"></script>' +
+              (esbuildPort
+                ? '<script>new EventSource("http://localhost:' +
+                  esbuildPort +
+                  '/esbuild").addEventListener("change", () => location.reload());</script>'
+                : ""),
+          ),
+      );
+    }
+
+    if (process.argv[2] == "build") {
+      const { build } = await import("esbuild");
+      if (existsSync("./dist/api.js")) {
+        await unlink("./dist/api.js");
+      }
+      await build({
+        bundle: true,
+        entryPoints: ["./index.css", "./src/prerender.js"],
+        outdir: "./dist",
+      });
+      await makeHtml();
+      return;
+    }
+
+    if (process.argv[2] == "dev" && cluster.isPrimary) {
+      const { context } = await import("esbuild");
+
+      const { watch: watchApi } = await context({
+        bundle: true,
+        entryPoints: ["./src/api.js"],
+        external: ["esbuild"],
+        outdir: "./dist",
+        platform: "node",
+      });
+      await watchApi();
+
+      const { serve: servePrerender, watch: watchPrerender } = await context({
+        bundle: true,
+        entryPoints: ["./index.css", "./src/prerender.js"],
+        outdir: "./dist",
+      });
+      await watchPrerender();
+      ({ port: esbuildPort } = await servePrerender({
+        cors: {
+          origin:
+            process.env["ORIGIN"] ||
+            `http://localhost:${Number(process.env["PORT"]) || 5173}`,
+        },
+      }));
+
+      let subprocess = cluster.fork();
+      let lastHash =
+        (await sha256("./dist/api.js")) +
+        (await sha256("./dist/index.css")) +
+        (await sha256("./dist/src/prerender.js"));
+      await makeHtml();
+      setInterval(async () => {
+        const hash =
+          (await sha256("./dist/api.js")) +
+          (await sha256("./dist/index.css")) +
+          (await sha256("./dist/src/prerender.js"));
+        if (hash != lastHash) {
+          lastHash = hash;
+          await makeHtml();
+          subprocess.kill();
+          subprocess = cluster.fork();
+        }
+      }, 1000);
+    }
+
+    await makeHtml();
+  }
+
   const port = Number(process.env["PORT"]) || 5173;
-  if (cluster.isPrimary && parallelism() > 1) {
+  if (
+    cluster.isPrimary &&
+    parallelism() > 1 &&
+    (!esbuild || !process.argv[2])
+  ) {
     /** @type {{ on(event: "message", callback: (message: any) => void): void, send(message: any, _: any, options: { keepOpen: boolean }): void }[]} */
     const forks = [];
     for (let i = 0; i < parallelism(); i++) {
@@ -226,7 +321,7 @@ export function listen(app) {
         }
       });
     }
-  } else {
+  } else if ((esbuild && !process.argv[2]) || cluster.isPrimary) {
     const server = app.listen(port, () => {
       if (cluster.isPrimary || process.env["i"] == "0") {
         console.log(
@@ -244,14 +339,20 @@ export function listen(app) {
   }
 }
 
-/** @param {{ html: string, prerender({ cookie, lang, url }: { cookie?: string | undefined, lang: string, url: string }): Promise<{ data: {}, head: { elements: Set<{ props: { [k: string]: string }, type: string }>, lang: string, title: string }, html: string }> }} props */
+/** @param {{ html?: string, prerender({ cookie, lang, url }: { cookie?: string | undefined, 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 }) {
+  if (!html) {
+    esbuild = true;
+  }
   /**
    * @param {import("node:http").IncomingMessage} req
    * @param {import("node:http").ServerResponse<import("node:http").IncomingMessage>} res
    */
   return async function onRequest(req, res) {
     try {
+      if (!html) {
+        html = await readFile("./dist/index.html", "utf-8");
+      }
       const rendered = await prerender({
         cookie: req.headers.cookie,
         lang: acceptLanguage.get(req.headers["accept-language"]) || "en",
@@ -271,9 +372,7 @@ export function production({ html, prerender }) {
       res.end(
         html
           .replace(/lang=".+?"/, () => `lang="${rendered.head.lang}"`)
-          .replace(/<title>.+<\/title>/, () =>
-            renderToString(h("title", null, rendered.head.title)),
-          )
+          .replace(/<title>.+<\/title>/, "")
           .replace(/<!--app-head-->[\s\S]+?<body/, (match) =>
             match
               .replace(/<link[^>]+>/g, (link) =>
@@ -283,19 +382,20 @@ export function production({ html, prerender }) {
           )
           .replace(
             `<!--app-head-->`,
-            [...rendered.head.elements.values()]
-              .map(
-                ({ props, type }) =>
-                  `<${type} ` +
-                  Object.entries(props)
-                    .map(([name, value]) => `${name}="${value}"`)
-                    .join(" ") +
-                  (type == "script" ? `</${type}>` : " />"),
-              )
-              .join(""),
+            renderToString(h("title", null, rendered.head.title)) +
+              [...rendered.head.elements.values()]
+                .map(
+                  ({ props, type }) =>
+                    `<${type} ` +
+                    Object.entries(props)
+                      .map(([name, value]) => `${name}="${value}"`)
+                      .join(" ") +
+                    (type == "script" ? `</${type}>` : " />"),
+                )
+                .join(""),
           )
           .replace(
-            /(<div id="app">)[\s\S]+<!--app-html-->/,
+            /(<div id="app">)[\s\S]*<!--app-html-->/,
             (_, div) =>
               div +
               rendered.html +
@@ -666,3 +766,12 @@ function ArrayOf(input) {
 function parallelism() {
   return Number(process.env["PARALLELISM"]) || availableParallelism();
 }
+
+/** @param {string} file */
+async function sha256(file) {
+  return existsSync(file)
+    ? createHash("sha256")
+        .update(await readFile(file))
+        .digest("hex")
+    : "";
+}

package/sqlite.js

@@ -323,7 +323,7 @@ export function sqlite({ pkg, schema }) {
               delete(where) {
                 if (
                   database
-                    .prepare(`delete from ${table}` + whereQuery({ where }))
+                    .prepare(`delete from ${table}` + whereQuery(where))
                     .run(...whereValues(where)).changes
                 ) {
                   publish({ table });
@@ -335,21 +335,23 @@ export function sqlite({ pkg, schema }) {
                 return select({ database, flat, join, schema, table });
               },
 
-              /** @param {{ set: Partial<import("valibot").InferOutput<(typeof schema)[typeof table]>>, where: import("./db.d.ts").Where<typeof schema, typeof table> }} props */
-              update({ set, where }) {
+              /** @param {import("./db.d.ts").Where<typeof schema, typeof table> & { set: Partial<import("valibot").InferOutput<(typeof schema)[typeof table]>>, where?: import("./db.d.ts").Where<typeof schema, typeof table> }} query */
+              update(query) {
                 if (
                   database
                     .prepare(
                       `update ${table} set\n` +
-                        Object.keys(set)
+                        Object.keys(query.set)
                           .map((name) => `${name} = ?`)
                           .join(",\n") +
-                        whereQuery({ where }),
+                        whereQuery(wherePropertyOrSelf(query)),
                     )
                     .run(
                       ...[
-                        ...Object.values(set).map((value) => value ?? null),
-                        ...whereValues(where),
+                        ...Object.values(query.set).map(
+                          (value) => value ?? null,
+                        ),
+                        ...whereValues(wherePropertyOrSelf(query)),
                       ],
                     ).changes
                 ) {
@@ -391,12 +393,12 @@ export function sqlite({ pkg, schema }) {
   };
 }
 
-/** @type {<Schema extends Record<string, import("valibot").ObjectSchema<any, any>>, R extends import("./db.d.ts").Relations<Schema> = import("./db.d.ts").Relations<Schema>, F extends import("./db.d.ts").Flatten<Schema> = import("./db.d.ts").Flatten<Schema>, Table extends keyof F & keyof Schema = keyof F & keyof Schema >(props: { database: DatabaseSync; flat: F; join?: import("./db.d.ts").Join<R, Table> & { limit?: number, offset?: number, order?: import("./db.d.ts").Order<Schema, Table>, where?: import("./db.d.ts").Where<Schema, Table> }; schema: Schema; table: Table; }) => any[]} */
+/** @type {<Schema extends Record<string, import("valibot").ObjectSchema<any, any>>, R extends import("./db.d.ts").Relations<Schema> = import("./db.d.ts").Relations<Schema>, F extends import("./db.d.ts").Flatten<Schema> = import("./db.d.ts").Flatten<Schema>, Table extends keyof F & keyof Schema = keyof F & keyof Schema >(props: { database: DatabaseSync; flat: F; join?: import("./db.d.ts").Join<R, Table> & import("./db.d.ts").Where<Schema, Table> & { limit?: number, offset?: number, order?: import("./db.d.ts").Order<Schema, Table>, where?: import("./db.d.ts").Where<Schema, Table> }; schema: Schema; table: Table; }) => any[]} */
 function select(props) {
   ok(typeof props.table == "string");
   let sql =
     `select * from ${props.table}` +
-    whereQuery({ where: props.join?.where }) +
+    whereQuery(wherePropertyOrSelf(props.join)) +
     (props.join?.order
       ? "\norder by " +
         (Array.isArray(props.join.order)
@@ -405,7 +407,7 @@ function select(props) {
         )
           .flatMap((column) =>
             Object.entries(column).map(([name, props]) =>
-              props?.desc ? `${name} desc` : name,
+              typeof props == "object" && props?.desc ? `${name} desc` : name,
             ),
           )
           .join(", ")
@@ -469,7 +471,7 @@ function select(props) {
 
   const rows = props.database
     .prepare(sql)
-    .all(...whereValues(props.join?.where));
+    .all(...whereValues(wherePropertyOrSelf(props.join)));
   if (!(/** @type {any} */ (props.join)?.with)) {
     for (const row of rows) {
       for (const name of Object.keys(row)) {
@@ -543,15 +545,28 @@ function select(props) {
   return state.entities;
 }
 
-/** @param {{ alias?: string, where: import("./db.js").Where<any, string> | undefined }} props */
-function whereQuery({ alias, where }) {
+let deprecatedFound = false;
+/** @param {{ where?: any } | undefined} props */
+function wherePropertyOrSelf(props) {
+  if (props?.where) {
+    if (!deprecatedFound) {
+      deprecatedFound = true;
+      console.error(
+        "`where: {}` is deprecated, move its properties one level above",
+      );
+    }
+    return props.where;
+  }
+  return props;
+}
+
+/** @param {import("./db.js").Where<any, string> | undefined} where */
+function whereQuery(where) {
   return (
     "\nwhere true\n" +
     Object.entries(where || {})
+      .filter(([name]) => !/^(limit|offset|order|set|with)$/.test(name))
       .map(([name, values]) => {
-        if (alias) {
-          name = `${alias}.${name}`;
-        }
         return Array.isArray(values)
           ? `and ${name} in (${values.map(() => "?").join(", ")})`
           : typeof values == "number" || typeof values == "string"
@@ -579,8 +594,9 @@ function whereQuery({ alias, where }) {
 
 /** @param {import("./db.js").Where<any, string> | undefined} where */
 function whereValues(where) {
-  return Object.values(where || {})
-    .flatMap((values) =>
+  return Object.entries(where || {})
+    .filter(([name]) => !/^(limit|offset|order|set|with)$/.test(name))
+    .flatMap(([, values]) =>
       Array.isArray(values)
         ? values
         : typeof values == "number" || typeof values == "string"