evikit 2.11.1 → 2.12.0

package/.woodpecker/test.yaml

@@ -1,38 +1,38 @@
-when:
-  - event: push
-    branch: main
-  - event: pull_request
-
-steps:
-  - name: build
-    image: node:24-alpine
-    commands:
-      - apk add git
-      # Are types correct?
-      - npm i
-      - npm run lint
-      - npx tsc
-      # Does todo app example build?
-      - npm create evikit my-app
-      - rm -rf my-app/node_modules/evikit
-      - (cd my-app/node_modules; git clone ../.. evikit)
-      - (cd my-app; npm run build)
-      # Does real-world application pass tests?
-      - git clone https://codeberg.org/nykula/lanquiz
-      - (cd lanquiz; npm i)
-      - rm -rf lanquiz/node_modules/evikit
-      - (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)
+when:
+  - event: push
+    branch: main
+  - event: pull_request
+
+steps:
+  - name: build
+    image: node:24-alpine
+    commands:
+      - apk add git
+      # Are types correct?
+      - npm i
+      - npm run lint
+      - npx tsc
+      # Does todo app example build?
+      - npm create evikit my-app
+      - rm -rf my-app/node_modules/evikit
+      - (cd my-app/node_modules; git clone ../.. evikit)
+      - (cd my-app; npm run build)
+      # Does real-world application pass tests?
+      - git clone https://codeberg.org/nykula/lanquiz
+      - (cd lanquiz; npm i)
+      - rm -rf lanquiz/node_modules/evikit
+      - (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

@@ -1,265 +1,272 @@
-import type {
-  InferInput,
-  InferMetadata,
-  InferOutput,
-  MetadataAction,
-  ObjectSchema,
-} from "valibot";
-
-export type Db<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Schema extends Record<string, ObjectSchema<any, any>>,
-  R extends Relations<Schema> = Relations<Schema>,
-  F extends Flatten<Schema> = Flatten<Schema>,
-> = {
-  [Table in keyof R]: Table extends keyof F & keyof Schema & string
-    ? {
-        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>;
-          },
-        >(
-          props?: W,
-        ): Select<Schema, R, F, Table, W>[];
-
-        update(query: {
-          set: Partial<InferOutput<Schema[Table]>>;
-          where: Where<Schema, Table>;
-        }): void;
-
-        upsert(
-          ...values: InferInput<Schema[Table]>[]
-        ): InferOutput<Schema[Table]>[];
-      }
-    : never;
-} & {
-  schema: Schema;
-  subscribe(onMessage: ({ table }: { table: string }) => void): () => void;
-};
-
-export type Flatten<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Schema extends Record<string, ObjectSchema<any, any>>,
-  R extends Relations<Schema> = Relations<Schema>,
-> = {
-  [Self in keyof R]: Self extends string
-    ? UnionToIntersection<
-        {
-          [Own in keyof R[Self]]: Own extends string
-            ? {
-                [Other in keyof R[Self][Own]]: Other extends string
-                  ? R[Self][Own][Other] extends Record<string, { name: string }>
-                    ? {
-                        [
-                          Its in keyof R[Self][Own][Other] as R[Self][Own][Other][Its]["name"]
-                        ]: Its extends string
-                          ? R[Self][Own][Other][Its]
-                          : never;
-                      }
-                    : never
-                  : never;
-              }[keyof R[Self][Own]]
-            : never;
-        }[keyof R[Self]]
-      >
-    : never;
-};
-
-export type Join<Relations, Self extends keyof Relations> = UnionToIntersection<
-  {
-    [Own in keyof Relations[Self]]: Own extends string
-      ? {
-          [Other in keyof Relations[Self][Own]]: Other extends keyof Relations
-            ? {
-                [Its in keyof Relations[Self][Own][Other]]: Its extends string
-                  ? Relations[Self][Own][Other] extends Record<
-                      string,
-                      { name: string }
-                    >
-                    ? {
-                        // Turning this into partial record would cause infinite depth.
-                        // eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style
-                        with: {
-                          [K in Relations[Self][Own][Other][Its]["name"]]?:
-                            Join<Relations, Other> | true;
-                        };
-                      }
-                    : never
-                  : never;
-              }[keyof Relations[Self][Own][Other]]
-            : never;
-        }[keyof Relations[Self][Own]]
-      : never;
-  }[keyof Relations[Self]]
->;
-
-export type Order<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  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 } }[];
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type Relations<Schema extends Record<string, ObjectSchema<any, any>>> = {
-  [Self in keyof Schema]: Self extends string
-    ? OmitExtendsRecordUndefined<{
-        [Own in keyof Schema[Self]["entries"]]: Own extends string
-          ? OmitExtendsRecordUndefined<{
-              [Other in keyof Schema]: Other extends string
-                ? OmitExtendsUndefined<{
-                    [Its in keyof Schema[Other]["entries"]]: Its extends string
-                      ? InferMetadata<Schema[Self]["entries"][Own]> extends {
-                          key: Schema[Other]["entries"][Its];
-                          references: Schema[Other];
-                        }
-                        ? Schema[Other] extends InferMetadata<
-                            Schema[Self]["entries"][Own]
-                          >["references"]
-                          ? Schema[Other]["entries"][Its] extends InferMetadata<
-                              Schema[Self]["entries"][Own]
-                            >["key"]
-                            ? {
-                                Its: Its;
-                                name: Rewrite<Self, Own, Other, Its>;
-                                Other: Other;
-                                Own: Own;
-                                type: "references";
-                              }
-                            : undefined
-                          : undefined
-                        : InferMetadata<Schema[Other]["entries"][Its]> extends {
-                              key: Schema[Self]["entries"][Own];
-                              references: Schema[Self];
-                            }
-                          ? Schema[Self] extends InferMetadata<
-                              Schema[Other]["entries"][Its]
-                            >["references"]
-                            ? Schema[Self]["entries"][Own] extends InferMetadata<
-                                Schema[Other]["entries"][Its]
-                              >["key"]
-                              ? {
-                                  Its: Its;
-                                  name: Rewrite<Self, Own, Other, Its>;
-                                  Other: Other;
-                                  Own: Own;
-                                  type: "referencedBy";
-                                }
-                              : undefined
-                            : undefined
-                          : undefined
-                      : undefined;
-                  }>
-                : undefined;
-            }>
-          : undefined;
-      }>
-    : undefined;
-};
-
-export type Where<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Schema extends Record<string, ObjectSchema<any, any>>,
-  Table extends keyof Schema,
-> = {
-  [K in keyof Schema[Table]["entries"]]?:
-    | InferOutput<Schema[Table]["entries"][K]>
-    | InferOutput<Schema[Table]["entries"][K]>[]
-    | Partial<
-        Record<
-          "gt" | "gte" | "lt" | "lte" | "not",
-          InferOutput<Schema[Table]["entries"][K]>
-        >
-      >;
-};
-
-type OmitExtends<T, U> = {
-  [K in keyof T as T[K] extends U ? never : K]: T[K];
-};
-
-type OmitExtendsRecordUndefined<T> = OmitExtends<T, Record<string, undefined>>;
-
-type OmitExtendsUndefined<T> = OmitExtends<T, undefined>;
-
-type Rewrite<
-  Self extends string,
-  Own extends string,
-  Other extends string,
-  Its extends string,
-> =
-  // Image.id, Question.imageId -> Image.Question.
-  Its extends `${Uncapitalize<Self>}${Capitalize<Own>}`
-    ? 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;
-
-type Select<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  Schema extends Record<string, ObjectSchema<any, any>>,
-  R extends Relations<Schema> = Relations<Schema>,
-  F extends Flatten<Schema> = Flatten<Schema>,
-  Table extends keyof F & keyof Schema = keyof F & keyof Schema,
-  W extends Join<R, Table> = Join<R, Table>,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-> = W extends { with: any }
-  ? InferOutput<Schema[Table]> & {
-      [K in keyof W["with"]]: K extends keyof F[Table]
-        ? F[Table][K] extends {
-            Other: keyof F & keyof Schema;
-            type: "referencedBy";
-          }
-          ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            (W["with"][K] extends { with: any }
-              ? Select<Schema, R, F, F[Table][K]["Other"], W["with"][K]>
-              : InferOutput<Schema[F[Table][K]["Other"]]>)[]
-          : F[Table][K] extends {
-                Other: keyof F & keyof Schema;
-                type: "references";
-              }
-            ? | undefined
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              | (W["with"][K] extends { with: any }
-                  ? Select<Schema, R, F, F[Table][K]["Other"], W["with"][K]>
-                  : InferOutput<Schema[F[Table][K]["Other"]]>)
-            : never
-        : never;
-    }
-  : InferOutput<Schema[Table]>;
-
-// https://www.geeksforgeeks.org/typescript/union-type-to-intersection-type-in-typescript/
-type UnionToIntersection<U> = (
-  U extends object ? (k: U) => void : never
-) extends (k: infer I) => void
-  ? I
-  : never;
-
-export function flatten<
-  Schema extends Record<string, ObjectSchema<any, any>>, // eslint-disable-line @typescript-eslint/no-explicit-any
->(relations: Relations<Schema>): Flatten<Schema>;
-
-export function primary<T>(): MetadataAction<T, { primary: true }>;
-
-export function references<
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  R extends { entries: any },
-  K extends keyof R["entries"],
-  T,
->(
-  references: R,
-  key: K,
-): MetadataAction<T, { key: R["entries"][K]; references: R }>;
-
-export function relations<
-  Schema extends Record<string, ObjectSchema<any, any>>, // eslint-disable-line @typescript-eslint/no-explicit-any
->(schema: Schema): Relations<Schema>;
+import type {
+  InferInput,
+  InferMetadata,
+  InferOutput,
+  MetadataAction,
+  ObjectSchema,
+} from "valibot";
+
+export type Db<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Schema extends Record<string, ObjectSchema<any, any>>,
+  R extends Relations<Schema> = Relations<Schema>,
+  F extends Flatten<Schema> = Flatten<Schema>,
+> = {
+  [Table in keyof R]: Table extends keyof F & keyof Schema & string
+    ? {
+        delete(where: Where<Schema, Table>): void;
+
+        select<
+          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: Where<Schema, Table> & {
+            set: Partial<InferOutput<Schema[Table]>>;
+            /** @deprecated */ where?: Where<Schema, Table>;
+          },
+        ): void;
+
+        upsert(
+          ...values: InferInput<Schema[Table]>[]
+        ): InferOutput<Schema[Table]>[];
+      }
+    : never;
+} & {
+  schema: Schema;
+  subscribe(onMessage: ({ table }: { table: string }) => void): () => void;
+};
+
+export type Flatten<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Schema extends Record<string, ObjectSchema<any, any>>,
+  R extends Relations<Schema> = Relations<Schema>,
+> = {
+  [Self in keyof R]: Self extends string
+    ? UnionToIntersection<
+        {
+          [Own in keyof R[Self]]: Own extends string
+            ? {
+                [Other in keyof R[Self][Own]]: Other extends string
+                  ? R[Self][Own][Other] extends Record<string, { name: string }>
+                    ? {
+                        [
+                          Its in keyof R[Self][Own][Other] as R[Self][Own][Other][Its]["name"]
+                        ]: Its extends string
+                          ? R[Self][Own][Other][Its]
+                          : never;
+                      }
+                    : never
+                  : never;
+              }[keyof R[Self][Own]]
+            : never;
+        }[keyof R[Self]]
+      >
+    : never;
+};
+
+export type Join<Relations, Self extends keyof Relations> = UnionToIntersection<
+  {
+    [Own in keyof Relations[Self]]: Own extends string
+      ? {
+          [Other in keyof Relations[Self][Own]]: Other extends keyof Relations
+            ? {
+                [Its in keyof Relations[Self][Own][Other]]: Its extends string
+                  ? Relations[Self][Own][Other] extends Record<
+                      string,
+                      { name: string }
+                    >
+                    ? {
+                        // Turning this into partial record would cause infinite depth.
+                        // eslint-disable-next-line @typescript-eslint/consistent-indexed-object-style
+                        with: {
+                          [K in Relations[Self][Own][Other][Its]["name"]]?:
+                            Join<Relations, Other> | true;
+                        };
+                      }
+                    : never
+                  : never;
+              }[keyof Relations[Self][Own][Other]]
+            : never;
+        }[keyof Relations[Self][Own]]
+      : never;
+  }[keyof Relations[Self]]
+>;
+
+export type Order<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Schema extends Record<string, ObjectSchema<any, any>>,
+  Table extends keyof Schema,
+> =
+  | {
+      [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>>> = {
+  [Self in keyof Schema]: Self extends string
+    ? OmitExtendsRecordUndefined<{
+        [Own in keyof Schema[Self]["entries"]]: Own extends string
+          ? OmitExtendsRecordUndefined<{
+              [Other in keyof Schema]: Other extends string
+                ? OmitExtendsUndefined<{
+                    [Its in keyof Schema[Other]["entries"]]: Its extends string
+                      ? InferMetadata<Schema[Self]["entries"][Own]> extends {
+                          key: Schema[Other]["entries"][Its];
+                          references: Schema[Other];
+                        }
+                        ? Schema[Other] extends InferMetadata<
+                            Schema[Self]["entries"][Own]
+                          >["references"]
+                          ? Schema[Other]["entries"][Its] extends InferMetadata<
+                              Schema[Self]["entries"][Own]
+                            >["key"]
+                            ? {
+                                Its: Its;
+                                name: Rewrite<Self, Own, Other, Its>;
+                                Other: Other;
+                                Own: Own;
+                                type: "references";
+                              }
+                            : undefined
+                          : undefined
+                        : InferMetadata<Schema[Other]["entries"][Its]> extends {
+                              key: Schema[Self]["entries"][Own];
+                              references: Schema[Self];
+                            }
+                          ? Schema[Self] extends InferMetadata<
+                              Schema[Other]["entries"][Its]
+                            >["references"]
+                            ? Schema[Self]["entries"][Own] extends InferMetadata<
+                                Schema[Other]["entries"][Its]
+                              >["key"]
+                              ? {
+                                  Its: Its;
+                                  name: Rewrite<Self, Own, Other, Its>;
+                                  Other: Other;
+                                  Own: Own;
+                                  type: "referencedBy";
+                                }
+                              : undefined
+                            : undefined
+                          : undefined
+                      : undefined;
+                  }>
+                : undefined;
+            }>
+          : undefined;
+      }>
+    : undefined;
+};
+
+export type Where<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Schema extends Record<string, ObjectSchema<any, any>>,
+  Table extends keyof Schema,
+> = {
+  [K in keyof Schema[Table]["entries"]]?:
+    | InferOutput<Schema[Table]["entries"][K]>
+    | InferOutput<Schema[Table]["entries"][K]>[]
+    | Partial<
+        Record<
+          "gt" | "gte" | "lt" | "lte" | "not",
+          InferOutput<Schema[Table]["entries"][K]>
+        >
+      >;
+};
+
+type OmitExtends<T, U> = {
+  [K in keyof T as T[K] extends U ? never : K]: T[K];
+};
+
+type OmitExtendsRecordUndefined<T> = OmitExtends<T, Record<string, undefined>>;
+
+type OmitExtendsUndefined<T> = OmitExtends<T, undefined>;
+
+type Rewrite<
+  Self extends string,
+  Own extends string,
+  Other extends string,
+  Its extends string,
+> =
+  // Image.id, Question.imageId -> Image.Question.
+  Its extends `${Uncapitalize<Self>}${Capitalize<Own>}`
+    ? 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;
+
+type Select<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Schema extends Record<string, ObjectSchema<any, any>>,
+  R extends Relations<Schema> = Relations<Schema>,
+  F extends Flatten<Schema> = Flatten<Schema>,
+  Table extends keyof F & keyof Schema = keyof F & keyof Schema,
+  W extends Join<R, Table> = Join<R, Table>,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+> = W extends { with: any }
+  ? InferOutput<Schema[Table]> & {
+      [K in keyof W["with"]]: K extends keyof F[Table]
+        ? F[Table][K] extends {
+            Other: keyof F & keyof Schema;
+            type: "referencedBy";
+          }
+          ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (W["with"][K] extends { with: any }
+              ? Select<Schema, R, F, F[Table][K]["Other"], W["with"][K]>
+              : InferOutput<Schema[F[Table][K]["Other"]]>)[]
+          : F[Table][K] extends {
+                Other: keyof F & keyof Schema;
+                type: "references";
+              }
+            ? | undefined
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              | (W["with"][K] extends { with: any }
+                  ? Select<Schema, R, F, F[Table][K]["Other"], W["with"][K]>
+                  : InferOutput<Schema[F[Table][K]["Other"]]>)
+            : never
+        : never;
+    }
+  : InferOutput<Schema[Table]>;
+
+// https://www.geeksforgeeks.org/typescript/union-type-to-intersection-type-in-typescript/
+type UnionToIntersection<U> = (
+  U extends object ? (k: U) => void : never
+) extends (k: infer I) => void
+  ? I
+  : never;
+
+export function flatten<
+  Schema extends Record<string, ObjectSchema<any, any>>, // eslint-disable-line @typescript-eslint/no-explicit-any
+>(relations: Relations<Schema>): Flatten<Schema>;
+
+export function primary<T>(): MetadataAction<T, { primary: true }>;
+
+export function references<
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  R extends { entries: any },
+  K extends keyof R["entries"],
+  T,
+>(
+  references: R,
+  key: K,
+): MetadataAction<T, { key: R["entries"][K]; references: R }>;
+
+export function relations<
+  Schema extends Record<string, ObjectSchema<any, any>>, // eslint-disable-line @typescript-eslint/no-explicit-any
+>(schema: Schema): Relations<Schema>;

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.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"