evikit 2.8.1 → 2.9.1

package/sqlite.js

@@ -302,16 +302,6 @@ export function sqlite({ pkg, schema }) {
           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(
@@ -329,25 +319,12 @@ export function sqlite({ pkg, schema }) {
           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 */
+              /** @param {import("./db.d.ts").Where<typeof schema, typeof table>} 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
+                    .prepare(`delete from ${table}` + whereQuery({ where }))
+                    .run(...whereValues(where)).changes
                 ) {
                   publish({ table });
                 }
@@ -355,15 +332,11 @@ export function sqlite({ pkg, schema }) {
 
               /** @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 */
+              /** @param {{ set: Partial<import("valibot").InferOutput<(typeof schema)[typeof table]>>, where: import("./db.d.ts").Where<typeof schema, typeof table> }} props */
               update({ set, where }) {
-                ensureArrayRecord(where);
                 if (
                   database
                     .prepare(
@@ -371,20 +344,12 @@ export function sqlite({ pkg, schema }) {
                         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"),
+                        whereQuery({ where }),
                     )
                     .run(
                       ...[
                         ...Object.values(set).map((value) => value ?? null),
-                        ...Object.values(where)
-                          .flatMap((values) => values)
-                          .map((value) => value ?? null),
+                        ...whereValues(where),
                       ],
                     ).changes
                 ) {
@@ -426,7 +391,7 @@ 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> & { 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[]} */
+/** @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?: import("./db.d.ts").Where<Schema, Table> }; schema: Schema; table: Table; }) => any[]} */
 function select(props) {
   ok(typeof props.table == "string");
   let alias = `${props.table}_0`;
@@ -484,19 +449,12 @@ function select(props) {
 
   join(0, props.table, alias, /** @type {any} */ (props.join));
   sql =
-    `select ${columns.join(",\n")} ${sql}\nwhere true\n` +
-    Object.entries(/** @type {any} */ (props.join)?.where || {})
-      .map(
-        ([name, values]) =>
-          `and ${alias}.${name} in (${values.map(() => "?").join(", ")})`,
-      )
-      .join("\n");
+    `select ${columns.join(",\n")} ${sql}` +
+    whereQuery({ alias, where: props.join?.where });
 
-  const rows = props.database.prepare(sql).all(
-    ...Object.values(/** @type {any} */ (props.join)?.where || {})
-      .flatMap((values) => values)
-      .map((value) => value ?? null),
-  );
+  const rows = props.database
+    .prepare(sql)
+    .all(...whereValues(props.join?.where));
   if (!(/** @type {any} */ (props.join)?.with)) {
     for (const row of rows) {
       for (const name of Object.keys(row)) {
@@ -569,3 +527,50 @@ function select(props) {
   ok(state);
   return state.entities;
 }
+
+/** @param {{ alias?: string, where: import("./db.js").Where<any, string> | undefined }} props */
+function whereQuery({ alias, where }) {
+  return (
+    "\nwhere true\n" +
+    Object.entries(where || {})
+      .map(([name, values]) => {
+        if (alias) {
+          name = `${alias}.${name}`;
+        }
+        return Array.isArray(values)
+          ? `and ${name} in (${values.map(() => "?").join(", ")})`
+          : typeof values == "number" || typeof values == "string"
+            ? `and ${name} = ?`
+            : Object.keys(values)
+                .map(
+                  (operator) =>
+                    `and ${name} ` +
+                    (operator == "gt"
+                      ? ">"
+                      : operator == "gte"
+                        ? ">="
+                        : operator == "lt"
+                          ? "<"
+                          : operator == "lte"
+                            ? "<="
+                            : "!=") +
+                    " ?",
+                )
+                .join("");
+      })
+      .join("\n")
+  );
+}
+
+/** @param {import("./db.js").Where<any, string> | undefined} where */
+function whereValues(where) {
+  return Object.values(where || {})
+    .flatMap((values) =>
+      Array.isArray(values)
+        ? values
+        : typeof values == "number" || typeof values == "string"
+          ? values
+          : Object.values(values),
+    )
+    .map((value) => value ?? null);
+}

package/use-api.d.ts

@@ -1,13 +1,13 @@
-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 };
+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,119 +1,119 @@
-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")
-  );
-}
+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")
+  );
+}