evikit 2.7.3 → 2.8.1

package/sqlite.js

@@ -277,109 +277,153 @@ export function sqlite({ pkg, schema }) {
     database.exec(sql);
   }
 
-  return /** @type {any} */ (
-    Object.fromEntries(
-      Object.entries(schema).map(([maybeTable]) => {
-        const table = /** @type {keyof typeof schema & string} */ (maybeTable);
-
-        /** @param {{ [K in keyof (typeof schema)[typeof table]["entries"]]?: import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]> | import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]>[]; }} where */
-        function ensureArrayRecord(where) {
-          for (const key of Object.keys(where)) {
-            if (!Array.isArray(where[key])) {
-              Object.assign(where, { [key]: [where[key]] });
+  /** @type {(({ table }: { table: string }) => void)[]} */
+  const listeners = [];
+  if (process.env["i"]) {
+    process.on("message", (maybeMessage) => {
+      for (const onMessage of listeners) {
+        onMessage(/** @type {any} */ (maybeMessage));
+      }
+    });
+  }
+  /** @param {{ table: string }} message */
+  function publish(message) {
+    Object.assign(message, { i: process.env["i"] });
+    process.send?.(message, undefined, { keepOpen: true });
+    for (const onMessage of listeners) {
+      onMessage(message);
+    }
+  }
+
+  return {
+    .../** @type {any} */ (
+      Object.fromEntries(
+        Object.entries(schema).map(([maybeTable]) => {
+          const table = /** @type {keyof typeof schema & string} */ (
+            maybeTable
+          );
+
+          /** @param {{ [K in keyof (typeof schema)[typeof table]["entries"]]?: import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]> | import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]>[]; }} where */
+          function ensureArrayRecord(where) {
+            for (const key of Object.keys(where)) {
+              if (!Array.isArray(where[key])) {
+                Object.assign(where, { [key]: [where[key]] });
+              }
             }
           }
-        }
 
-        ok(schema[table]);
-        const columns = Object.entries(schema[table].entries);
-        const primaryKey = columns.find(
-          ([, column]) =>
-            /** @type {{ primary?: true }} */ (getMetadata(column)).primary,
-        );
-        ok(primaryKey);
-        const upsert = database.prepare(
-          `insert into ${table} (${columns.map(([name]) => name).join(", ")}) values\n` +
-            `(${columns.map(() => "?").join(", ")})\n` +
-            `on conflict (${primaryKey[0]}) do update set\n` +
-            columns.map(([name]) => `${name} = ?`).join(",\n"),
-        );
+          ok(schema[table]);
+          const columns = Object.entries(schema[table].entries);
+          const primaryKey = columns.find(
+            ([, column]) =>
+              /** @type {{ primary?: true }} */ (getMetadata(column)).primary,
+          );
+          ok(primaryKey);
+          const upsert = database.prepare(
+            `insert into ${table} (${columns.map(([name]) => name).join(", ")}) values\n` +
+              `(${columns.map(() => "?").join(", ")})\n` +
+              `on conflict (${primaryKey[0]}) do update set\n` +
+              columns.map(([name]) => `${name} = ?`).join(",\n"),
+          );
 
-        return [
-          table,
-          {
-            /** @param {{ [K in keyof (typeof schema)[typeof table]["entries"]]?: import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]> | import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]>[]; }} where */
-            delete(where) {
-              ensureArrayRecord(where);
-              database
-                .prepare(
-                  `delete from ${table} where true\n` +
-                    Object.entries(where)
-                      .map(
-                        ([name, values]) =>
-                          `and ${name} in (${values.map(() => "?").join(", ")})`,
-                      )
-                      .join("\n"),
-                )
-                .run(
-                  ...Object.values(where)
-                    .flatMap((values) => values)
-                    .map((value) => value ?? null),
-                );
-            },
+          return [
+            table,
+            {
+              /** @param {{ [K in keyof (typeof schema)[typeof table]["entries"]]?: import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]> | import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]>[]; }} where */
+              delete(where) {
+                ensureArrayRecord(where);
+                if (
+                  database
+                    .prepare(
+                      `delete from ${table} where true\n` +
+                        Object.entries(where)
+                          .map(
+                            ([name, values]) =>
+                              `and ${name} in (${values.map(() => "?").join(", ")})`,
+                          )
+                          .join("\n"),
+                    )
+                    .run(
+                      ...Object.values(where)
+                        .flatMap((values) => values)
+                        .map((value) => value ?? null),
+                    ).changes
+                ) {
+                  publish({ table });
+                }
+              },
 
-            /** @param {any} join */
-            select(join) {
-              if (join?.where) {
-                ensureArrayRecord(join.where);
-              }
-              return select({ database, flat, join, schema, table });
-            },
+              /** @param {any} join */
+              select(join) {
+                if (join?.where) {
+                  ensureArrayRecord(join.where);
+                }
+                return select({ database, flat, join, schema, table });
+              },
 
-            /** @param {{ set: Partial<import("valibot").InferOutput<(typeof schema)[typeof table]>>, where: { [K in keyof (typeof schema)[typeof table]["entries"]]?: import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]> | import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]>[]; } }} props */
-            update({ set, where }) {
-              ensureArrayRecord(where);
-              database
-                .prepare(
-                  `update ${table} set\n` +
-                    Object.keys(set)
-                      .map((name) => `${name} = ?`)
-                      .join(",\n") +
-                    `\nwhere true\n` +
-                    Object.entries(where)
-                      .map(
-                        ([name, values]) =>
-                          `and ${name} in (${values.map(() => "?").join(", ")})`,
-                      )
-                      .join("\n"),
-                )
-                .run(
-                  ...[
-                    ...Object.values(set).map((value) => value ?? null),
-                    ...Object.values(where)
-                      .flatMap((values) => values)
-                      .map((value) => value ?? null),
-                  ],
-                );
-            },
+              /** @param {{ set: Partial<import("valibot").InferOutput<(typeof schema)[typeof table]>>, where: { [K in keyof (typeof schema)[typeof table]["entries"]]?: import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]> | import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]>[]; } }} props */
+              update({ set, where }) {
+                ensureArrayRecord(where);
+                if (
+                  database
+                    .prepare(
+                      `update ${table} set\n` +
+                        Object.keys(set)
+                          .map((name) => `${name} = ?`)
+                          .join(",\n") +
+                        `\nwhere true\n` +
+                        Object.entries(where)
+                          .map(
+                            ([name, values]) =>
+                              `and ${name} in (${values.map(() => "?").join(", ")})`,
+                          )
+                          .join("\n"),
+                    )
+                    .run(
+                      ...[
+                        ...Object.values(set).map((value) => value ?? null),
+                        ...Object.values(where)
+                          .flatMap((values) => values)
+                          .map((value) => value ?? null),
+                      ],
+                    ).changes
+                ) {
+                  publish({ table });
+                }
+              },
 
-            /** @param {any[]} values */
-            upsert(...values) {
-              ok(schema[table]);
-              const outputs = [];
-              for (const row of values) {
-                const output = parse(schema[table], row);
-                const values = columns.map(([name]) => output[name] ?? null);
-                upsert.run(...values, ...values);
-                outputs.push(output);
-              }
-              return outputs;
+              /** @param {any[]} values */
+              upsert(...values) {
+                ok(schema[table]);
+                const outputs = [];
+                /** @type {boolean} */
+                let changes = false;
+                for (const row of values) {
+                  const output = parse(schema[table], row);
+                  const values = columns.map(([name]) => output[name] ?? null);
+                  if (upsert.run(...values, ...values).changes) {
+                    changes = true;
+                  }
+                  outputs.push(output);
+                }
+                if (changes) {
+                  publish({ table });
+                }
+                return outputs;
+              },
             },
-          },
-        ];
-      }),
-    )
-  );
+          ];
+        }),
+      )
+    ),
+    schema,
+    subscribe(onMessage) {
+      listeners.push(onMessage);
+      return () => {
+        listeners.splice(listeners.indexOf(onMessage), 1);
+      };
+    },
+  };
 }
 
 /** @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> & { where?: { [K in keyof Schema[Table]["entries"]]?: import("valibot").InferOutput<Schema[Table]["entries"][K]> | import("valibot").InferOutput<Schema[Table]["entries"][K]>[]; } }; schema: Schema; table: Table; }) => any[]} */

package/use-api.d.ts

@@ -1,12 +1,13 @@
-import { type InferOutput, type ObjectSchema } from "valibot";
-
-export function queryApi<T, U extends ObjectSchema<T, undefined>>(props: {
-  lang?: string;
-  origin: string | undefined;
-  path: string;
-  schema?: U;
-}): { queryFn: () => Promise<InferOutput<U>>; queryKey: string[] };
-
-export function useApi<T, U extends ObjectSchema<T, undefined>>(routeType: {
-  outputs: { 200: U };
-}): { data?: InferOutput<U>; error?: unknown };
+import { type InferOutput, type ObjectSchema } from "valibot";
+
+export function queryApi<T, U extends ObjectSchema<T, undefined>>(props: {
+  cookie?: string | undefined;
+  lang?: string;
+  origin: string | undefined;
+  path: string;
+  schema?: U;
+}): { queryFn: () => Promise<InferOutput<U>>; queryKey: string[] };
+
+export function useApi<T, U extends ObjectSchema<T, undefined>>(routeType: {
+  outputs: { 200: U };
+}): { data?: InferOutput<U>; error?: unknown };

package/use-api.js

@@ -1,47 +1,119 @@
-import { useRoute } from "preact-iso";
-import { parse } from "valibot";
-
-import { jsdomCookie } from "./jsdom-cookie.js";
-import { useQuery } from "./query.js";
-
-/** @param {{ lang?: string, origin: string | undefined, path: string, schema?: any }} props */
-export function queryApi({ lang, origin, path, schema }) {
-  const queryKey =
-    path == "/" ? ["home"] : path.split("/").slice(1).map(decodeURIComponent);
-
-  return {
-    queryFn: async () => {
-      const response = await fetch(
-        (origin || "") +
-          path.replace(/^\//, "/api/").replace(/^\/api\/(\?|$)/, "/api$1"),
-        {
-          headers: {
-            ...(lang ? { "Accept-Language": lang } : {}),
-            Cookie: jsdomCookie.setCookie.join("; "),
-          },
-        },
-      );
-      if (response.status >= 400) {
-        const error = new Error(await response.text());
-        error.name = response.status.toString();
-        throw Error;
-      }
-      const json = await response.json();
-      return schema ? parse(schema, json) : json;
-    },
-    queryKey,
-  };
-}
-
-/** @param {{ outputs: { 200: any } }} routeType */
-export function useApi(routeType) {
-  const { path, query } = useRoute();
-  const search = new URLSearchParams(query).toString();
-  const { queryFn, queryKey } = queryApi({
-    origin: location.origin,
-    path: path + (search ? `?${search}` : ""),
-    schema: routeType.outputs[200],
-  });
-  const { data, error } = useQuery({ queryFn, queryKey });
-  return { data, error };
-}
+import { useRoute } from "preact-iso";
+import { useEffect, useState } from "preact/hooks";
+import { parse } from "valibot";
+
+import { jsdomCookie } from "./jsdom-cookie.js";
+import { SetQueryState, useQuery, useQueryClient } from "./query.js";
+
+/** @param {{ cookie?: string | undefined, lang?: string, origin: string | undefined, path: string, schema?: any }} props */
+export function queryApi({ cookie, lang, origin, path, schema }) {
+  const queryKey =
+    path == "/" ? ["home"] : path.split("/").slice(1).map(decodeURIComponent);
+
+  return {
+    queryFn: async () => {
+      const response = await fetch(ApiPath({ origin, path }), {
+        headers: {
+          ...(lang ? { "Accept-Language": lang } : {}),
+          Cookie: [...(cookie ? [cookie] : []), ...jsdomCookie.setCookie].join(
+            "; ",
+          ),
+        },
+      });
+      if (response.status >= 400) {
+        const error = new Error(await response.text());
+        error.name = response.status.toString();
+        throw Error;
+      }
+      const json = await response.json();
+      return schema ? parse(schema, json) : json;
+    },
+    queryKey,
+  };
+}
+
+/** @param {{ outputs: { 200: any } }} routeType */
+export function useApi(routeType) {
+  const { origin } = location;
+  const { path: pathWithoutSearch, query } = useRoute();
+  const search = new URLSearchParams(query).toString();
+  const path = pathWithoutSearch + (search ? `?${search}` : "");
+  const schema = routeType.outputs[200];
+  const { queryFn, queryKey } = queryApi({ origin, path, schema });
+  const { data, error } = useQuery({ queryFn, queryKey });
+  const queryClient = useQueryClient();
+  const setQueryState = SetQueryState({ queryClient, queryKey });
+  const [sourceUpdatedAt, setSourceUpdatedAt] = useState(Date.now());
+  const [cookieChangedAt, setCookieChangedAt] = useState(Date.now());
+  useEffect(() => {
+    if (typeof cookieStore == "undefined") {
+      return;
+    }
+    function onCookie() {
+      queryClient.invalidateQueries({ evenIfEventSource: true, queryKey });
+      setCookieChangedAt(Date.now());
+    }
+    cookieStore.addEventListener("change", onCookie);
+    return () => cookieStore.removeEventListener("change", onCookie);
+  }, []);
+  useEffect(() => {
+    if (typeof EventSource == "undefined") {
+      return;
+    }
+    const source = new EventSource(ApiPath({ origin, path: path }));
+    source.onerror = () => {
+      setTimeout(() => {
+        setSourceUpdatedAt(Date.now());
+      }, 1e3);
+    };
+    source.onmessage = ({ data }) => {
+      data = JSON.parse(data);
+      if (!data) {
+        source.close();
+        setQueryState((existing) =>
+          existing ? { ...existing, fromEventSource: false } : undefined,
+        );
+      } else if (Number(data.statusCode) >= 400) {
+        setQueryState((existing) => ({
+          data: existing?.data ?? null,
+          dataUpdatedAt: Date.now(),
+          error,
+          fromEventSource: true,
+          isInvalidated: false,
+          /** @type {"error"} */
+          status: "error",
+        }));
+      } else {
+        setQueryState(() => ({
+          data: schema
+            ? parse(schema, JSON.parse(data.body))
+            : JSON.parse(data.body),
+          dataUpdatedAt: Date.now(),
+          error: null,
+          fromEventSource: true,
+          isInvalidated: false,
+          /** @type {"success"} */
+          status: "success",
+        }));
+      }
+    };
+    setQueryState((existing) =>
+      existing ? { ...existing, fromEventSource: true } : undefined,
+    );
+    return () => {
+      source.close();
+      setQueryState((existing) =>
+        existing ? { ...existing, fromEventSource: false } : undefined,
+      );
+    };
+  }, [cookieChangedAt, path, sourceUpdatedAt]);
+  return { data, error };
+}
+
+/** @param {{ origin: string | undefined, path: string }} props */
+function ApiPath({ origin, path }) {
+  return (
+    (origin || "") +
+    path.replace(/^\//, "/api/").replace(/^\/api\/(\?|$)/, "/api$1")
+  );
+}