evikit 2.10.1 → 2.11.1

package/.woodpecker/test.yaml

@@ -1,26 +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)
+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

@@ -218,7 +218,7 @@ export function api() {
 
 #### Page router
 
-Add a Preact router at `src/app.js` (uncomment the routes one-by-one when we add them later):
+Add a Preact router at `src/prerender.js` (uncomment the routes one-by-one when we add them later):
 
 ```js
 import { route, ssr } from "evikit";
@@ -252,7 +252,7 @@ Make an HTML template `index.html`, leaving placeholders for server-rendered con
   </head>
   <body>
     <div id="app"><!--app-html--></div>
-    <script prerender type="module" src="/src/app.js"></script>
+    <script prerender type="module" src="/src/prerender.js"></script>
   </body>
 </html>
 ```
@@ -308,7 +308,7 @@ import { readFile } from "node:fs/promises";
 import swaggerUi from "swagger-ui-express";
 
 import { api } from "./src/api.js";
-import { prerender } from "./src/app.js";
+import { prerender } from "./src/prerender.js";
 
 const app = express();
 app.use(api().onRequest);
@@ -433,7 +433,7 @@ export function HomePage() {
 }
 ```
 
-Uncomment the `HomePage` import and `/` route in `src/app.js`.
+Uncomment the `HomePage` import and `/` route in `src/prerender.js`.
 
 #### Forms
 
@@ -524,7 +524,7 @@ export function QuestionIdPage() {
 }
 ```
 
-Uncomment the `QuestionIdPage` import and `/question/:id` route in `src/app.js`.
+Uncomment the `QuestionIdPage` import and `/question/:id` route in `src/prerender.js`.
 
 ##### Suggest own option
 
@@ -789,8 +789,9 @@ import { ok } from "node:assert/strict";
 
 // ...
 
-const Question = db.Question.select({
+const [question] = db.Question.select({
   with: { Choice: { with: { iconStorage: true } } },
+  where: { id: input.id },
 });
 
 // ...

package/db.d.ts

@@ -1,255 +1,265 @@
-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?: 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]]
->;
-
-// 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
-    : // 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;
-
-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>> & {
+            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>;

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 Its == `${uncapitalize(Self)}${capitalize(Own)}`
-    ? Other
-    : // Question.quizId, Quiz.id -> Question.Quiz.
-      Own == `${uncapitalize(Other)}${capitalize(Its)}`
-      ? 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.10.1",
+  "version": "2.11.1",
   "type": "module",
   "exports": {
     ".": "./index.js",

package/sqlite.js

@@ -391,17 +391,35 @@ 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?: 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> & { 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 alias = `${props.table}_0`;
-  let sql = `from ${props.table} ${alias}`;
+  let sql =
+    `select * from ${props.table}` +
+    whereQuery({ where: props.join?.where }) +
+    (props.join?.order
+      ? "\norder by " +
+        (Array.isArray(props.join.order)
+          ? props.join.order
+          : [props.join.order]
+        )
+          .flatMap((column) =>
+            Object.entries(column).map(([name, props]) =>
+              props?.desc ? `${name} desc` : name,
+            ),
+          )
+          .join(", ")
+      : "") +
+    (props.join?.offset ? `\noffset ${props.join.offset}` : "") +
+    (props.join?.limit ? `\nlimit ${props.join.limit}` : "");
 
+  let alias = `${props.table}_0`;
   let columns = Object.keys(
     /** @type {any} */ (props.schema)[props.table].entries,
   );
   if (/** @type {any} */ (props.join)?.with) {
     columns = columns.map((name) => `${alias}.${name} ${alias}_${name}`);
+    sql = `select COLUMNS\nfrom (${sql}) ${alias}`;
   }
 
   /** @type {Record<string, { entities: any[]; table: string }>} */
@@ -446,11 +464,8 @@ function select(props) {
       }
     }
   }
-
   join(0, props.table, alias, /** @type {any} */ (props.join));
-  sql =
-    `select ${columns.join(",\n")} ${sql}` +
-    whereQuery({ alias, where: props.join?.where });
+  sql = sql.replace("COLUMNS", columns.join(",\n  "));
 
   const rows = props.database
     .prepare(sql)