evikit 2.11.0 → 2.12.0

package/.woodpecker/test.yaml

@@ -24,3 +24,15 @@ steps:
       - (cd lanquiz/node_modules; git clone ../.. evikit)
       - (cd lanquiz; npm run build)
       - (cd lanquiz; npm test -- --test-concurrency=1)
+      # Do other real-world applications build? 1/2
+      - git clone https://codeberg.org/nykula/mobhub
+      - (cd mobhub; npm i)
+      - rm -rf mobhub/node_modules/evikit
+      - (cd mobhub/node_modules; git clone ../.. evikit)
+      - (cd mobhub; npm run build)
+      # Do other real-world applications build? 2/2
+      - git clone https://codeberg.org/nykula/yoself
+      - (cd yoself; npm i)
+      - rm -rf yoself/node_modules/evikit
+      - (cd yoself/node_modules; git clone ../.. evikit)
+      - (cd yoself; npm run build)

package/README.md

@@ -473,8 +473,8 @@ export const QuestionIdServer = {
   get: endpoint(QuestionIdGet, async ({ input }) => {
     const i18n = await getI18n(input.lang);
     const [question] = db.Question.select({
+      id: input.id,
       with: { Choice: true },
-      where: { id: input.id },
     });
     // It maps join results to objects, for example you can get:
     // question?.Choice[0]?.text
@@ -557,7 +557,7 @@ export const ChoiceServer = {
   post: endpoint(ChoicePost, async ({ input }) => {
     const i18n = await getI18n(input.lang);
 
-    const [question] = db.Question.select({ where: { id: input.questionId } });
+    const [question] = db.Question.select({ id: input.questionId });
     if (!question) {
       return text(i18n.gettext("Question does not exist"), 400);
     }
@@ -638,7 +638,7 @@ export const VoteServer = {
   post: endpoint(VotePost, async ({ input }) => {
     const i18n = await getI18n(input.lang);
 
-    const [choice] = db.Choice.select({ where: { id: input.choiceId } });
+    const [choice] = db.Choice.select({ id: input.choiceId });
     if (!choice) {
       return text(i18n.gettext("You didn't select a choice"), 400);
     }
@@ -648,9 +648,9 @@ export const VoteServer = {
     }
 
     db.Choice.update({
+      id: choice.id,
       set: { votes: choice.votes + 1 },
-      where: { id: choice.id },
-      // To update multiple choices, pass an array of ids to `where.id`.
+      // To update multiple choices, pass an array of ids to `id`.
     });
     // To delete a choice: `db.Choice.delete({ id: choice.id })`.
     // To delete multiple choices, pass an array of ids to `id`.
@@ -790,8 +790,8 @@ import { ok } from "node:assert/strict";
 // ...
 
 const [question] = db.Question.select({
+  id: input.id,
   with: { Choice: { with: { iconStorage: true } } },
-  where: { id: input.id },
 });
 
 // ...

package/db.d.ts

@@ -17,20 +17,23 @@ export type Db<
         delete(where: Where<Schema, Table>): void;
 
         select<
-          W extends Partial<Join<R, Table>> & {
-            limit?: number;
-            offset?: number;
-            order?: Order<Schema, Table>;
-            where?: Where<Schema, Table>;
-          },
+          W extends Partial<Join<R, Table>> &
+            Where<Schema, Table> & {
+              limit?: number;
+              offset?: number;
+              order?: Order<Schema, Table>;
+              /** @deprecated */ where?: Where<Schema, Table>;
+            },
         >(
           props?: W,
         ): Select<Schema, R, F, Table, W>[];
 
-        update(query: {
-          set: Partial<InferOutput<Schema[Table]>>;
-          where: Where<Schema, Table>;
-        }): void;
+        update(
+          query: Where<Schema, Table> & {
+            set: Partial<InferOutput<Schema[Table]>>;
+            /** @deprecated */ where?: Where<Schema, Table>;
+          },
+        ): void;
 
         upsert(
           ...values: InferInput<Schema[Table]>[]
@@ -103,8 +106,12 @@ export type Order<
   Schema extends Record<string, ObjectSchema<any, any>>,
   Table extends keyof Schema,
 > =
-  | { [K in keyof Schema[Table]["entries"]]?: null | { desc: true } }
-  | { [K in keyof Schema[Table]["entries"]]?: null | { desc: true } }[];
+  | {
+      [K in keyof Schema[Table]["entries"]]?: null | true | { desc: true };
+    }
+  | {
+      [K in keyof Schema[Table]["entries"]]?: null | true | { desc: true };
+    }[];
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type Relations<Schema extends Record<string, ObjectSchema<any, any>>> = {
@@ -196,16 +203,13 @@ type Rewrite<
   // Image.id, Question.imageId -> Image.Question.
   Its extends `${Uncapitalize<Self>}${Capitalize<Own>}`
     ? Other
-    : // Question.quizId, Quiz.id -> Question.Quiz.
-      Own extends `${Uncapitalize<Other>}${Capitalize<Its>}`
-      ? Other
-      : // Quiz.coverId, Image.id -> Quiz.cover.
-        Own extends `${infer R}${Capitalize<Its>}`
-        ? R
-        : // Image.id, Quiz.coverId -> Image.CoverQuiz.
-          Its extends `${infer R}${Capitalize<Own>}`
-          ? `${Capitalize<R>}${Other}`
-          : never;
+    : // Quiz.coverId, Image.id -> Quiz.cover.
+      Own extends `${infer R}${Capitalize<Its>}`
+      ? R
+      : // Image.id, Quiz.coverId -> Image.CoverQuiz.
+        Its extends `${infer R}${Capitalize<Own>}`
+        ? `${Capitalize<R>}${Other}`
+        : never;
 
 type Select<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/db.js

@@ -108,10 +108,9 @@ function capitalize(input) {
  * @param {string} Its
  */
 function rewrite(Self, Own, Other, Its) {
-  return Its == `${uncapitalize(Self)}${capitalize(Own)}`
-    ? Other
-    : // Question.quizId, Quiz.id -> Question.Quiz.
-      Own == `${uncapitalize(Other)}${capitalize(Its)}`
+  return (
+    // Image.id, Question.imageId -> Image.Question.
+    Its == `${uncapitalize(Self)}${capitalize(Own)}`
       ? Other
       : // Quiz.coverId, Image.id -> Quiz.cover.
         Own.endsWith(capitalize(Its))
@@ -119,7 +118,8 @@ function rewrite(Self, Own, Other, Its) {
         : // Image.id, Quiz.coverId -> Image.CoverQuiz.
           Its.endsWith(capitalize(Own))
           ? `${capitalize(Its.slice(0, -Own.length))}${Other}`
-          : undefined;
+          : undefined
+  );
 }
 
 /** @param {string} input */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "evikit",
   "description": "Preact/SQLite SSR framework for small web apps",
-  "version": "2.11.0",
+  "version": "2.12.0",
   "type": "module",
   "exports": {
     ".": "./index.js",

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"