evikit 2.5.3 → 2.6.1

package/db.d.ts

@@ -20,8 +20,15 @@ export type Db<
             | InferOutput<Schema[Table]["entries"][K]>[];
         }): void;
 
-        // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-        select<W extends Join<R, Table> = { with: {} }>(
+        select<
+          W extends Partial<Join<R, Table>> & {
+            where?: {
+              [K in keyof Schema[Table]["entries"]]?:
+                | InferOutput<Schema[Table]["entries"][K]>
+                | InferOutput<Schema[Table]["entries"][K]>[];
+            };
+          },
+        >(
           props?: W,
         ): Select<Schema, R, F, Table, W>[];
 
@@ -213,7 +220,7 @@ type Select<
             : never
         : never;
     }
-  : never;
+  : InferOutput<Schema[Table]>;
 
 // https://www.geeksforgeeks.org/typescript/union-type-to-intersection-type-in-typescript/
 type UnionToIntersection<U> = (

package/package.json

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

package/sqlite.js

@@ -1,496 +1,525 @@
-import envPaths from "env-paths";
-import { fail, ok } from "node:assert/strict";
-import { mkdirSync } from "node:fs";
-import { DatabaseSync } from "node:sqlite";
-import { getMetadata, parse } from "valibot";
-
-import { flatten, relations } from "./db.js";
-
-/**
- * @typedef Column
- * @property {string} name
- * @property {0 | 1} notnull
- * @property {0 | 1} pk
- * @property {"INTEGER" | "TEXT"} type
- */
-
-/** @type {typeof import("./sqlite.d.ts").sqlite} */
-export function sqlite({ pkg, schema }) {
-  const data = pkg
-    ? (() => {
-        const { data } = envPaths(pkg.name);
-        mkdirSync(data, { recursive: true });
-        return data;
-      })()
-    : undefined;
-  const database = new DatabaseSync(data ? `${data}/db.sqlite3` : ":memory:", {
-    timeout: 1000,
-  });
-  const flat = flatten(relations(schema));
-
-  const haveTables = /** @type {{ name: string }[]} */ (
-    database
-      .prepare(
-        "select * from sqlite_schema where type='table' and name not like 'sqlite_%'",
-      )
-      .all()
-  ).map((table) => {
-    const columns = /** @type {Column[]} */ (
-      database.prepare(`pragma table_info(${table.name})`).all()
-    );
-    const foreignKeys =
-      /** @type {{ from: string, on_delete: "CASCADE" | "SET NULL", on_update: "CASCADE" | "SET NULL", table: string, to: string, }[]} */ (
-        database.prepare(`pragma foreign_key_list(${table.name})`).all()
-      );
-    return {
-      columns,
-      foreignKeys,
-      indices: /** @type {{ name: string }[]} */ (
-        database.prepare(`pragma index_list(${table.name})`).all()
-      )
-        .filter(({ name }) => !/^sqlite_/.test(name))
-        .map((index) => ({
-          ...index,
-          info: /** @type {{ name: string; }} */ (
-            database.prepare(`pragma index_info(${index.name})`).get()
-          ),
-        })),
-      table,
-    };
-  });
-
-  const wantTables = Object.entries(schema).map(([name, { entries }]) => ({
-    columns: Object.entries(entries).map(([name, maybeEntry]) => {
-      const entry =
-        /** @type {import("valibot").BaseSchema<undefined, undefined, any>} */ (
-          maybeEntry
-        );
-      const pk = /** @type {{ primary?: true }} */ (getMetadata(entry)).primary
-        ? 1
-        : 0;
-      return {
-        name,
-        notnull: !pk && entry.expects.includes("undefined") ? 0 : 1,
-        pk,
-        type:
-          entry.expects == "string" || entry.expects == "(string | undefined)"
-            ? "TEXT"
-            : entry.expects == "number" ||
-                entry.expects == "(number | undefined)"
-              ? "INTEGER"
-              : entry.expects == "Uint8Array" ||
-                  entry.expects == "(Uint8Array | undefined)"
-                ? "BLOB"
-                : fail(name),
-      };
-    }),
-    foreignKeys: Object.entries(entries)
-      .map(([name, maybeEntry]) => {
-        const entry =
-          /** @type {import("valibot").BaseSchema<undefined, undefined, any>} */ (
-            maybeEntry
-          );
-
-        const metadata =
-          /** @type {{ key?: string, references?: any } | undefined} */ (
-            getMetadata(entry)
-          );
-        const table = metadata
-          ? Object.entries(schema)
-              .filter(([, value]) => value == metadata.references)
-              .find(Boolean)
-          : undefined;
-        if (!metadata?.references) {
-          return;
-        }
-        ok(table);
-        const to = Object.entries(table[1].entries).find(
-          ([, value]) => value == metadata.key,
-        );
-        ok(to);
-        return {
-          from: name,
-          on_delete: /undefined/.test(entry.expects) ? "SET NULL" : "CASCADE",
-          on_update: /undefined/.test(entry.expects) ? "SET NULL" : "CASCADE",
-          table: table[0],
-          to: to[0],
-        };
-      })
-      .filter(Boolean)
-      .map((x) => {
-        ok(x);
-        return x;
-      }),
-    table: { name },
-  }));
-
-  const migration = [];
-
-  for (const wantTable of wantTables) {
-    const haveTable = haveTables.find(
-      ({ table }) => table.name == wantTable.table.name,
-    );
-    if (haveTable) {
-      for (const { info, name } of haveTable.indices) {
-        if (!wantTable.foreignKeys.find(({ from }) => from == info.name)) {
-          migration.push(`drop index ${name}`);
-        }
-      }
-      const haveColumns = haveTable.columns;
-      const columnsNowMissing = haveColumns.filter(
-        (haveColumn) =>
-          !wantTable.columns.find(({ name }) => name == haveColumn.name),
-      );
-      for (const { name, pk } of columnsNowMissing) {
-        if (pk) {
-          fail(`${haveTable.table.name}.${name}: Can't drop primary key`);
-        }
-      }
-      for (const wantColumn of wantTable.columns) {
-        const haveColumn = haveColumns.find(
-          ({ name }) => name == wantColumn.name,
-        );
-
-        /** @param {Column} column */
-        function checkConstraint(column) {
-          ok(column);
-          ok(haveTable);
-          if (column.pk != wantColumn.pk) {
-            fail(
-              `${haveTable.table.name}.${column.name}: Can't toggle primary key`,
-            );
-          }
-          if (
-            !wantColumn.pk && // Without this condition I get an error with real database created by drizzle-kit.
-            column.notnull != wantColumn.notnull
-          ) {
-            fail(
-              `${haveTable.table.name}.${column.name}: Can't toggle optional`,
-            );
-          }
-        }
-
-        if (haveColumn) {
-          checkConstraint(haveColumn);
-        } else {
-          const renamedColumn = columnsNowMissing.find(
-            ({ notnull, type }) =>
-              wantColumn.type == type && wantColumn.notnull == notnull,
-          );
-          if (renamedColumn) {
-            checkConstraint(renamedColumn);
-            columnsNowMissing.splice(
-              columnsNowMissing.indexOf(renamedColumn),
-              1,
-            );
-            migration.push(
-              `alter table ${wantTable.table.name} rename column ${renamedColumn.name} to ${wantColumn.name}`,
-            );
-          } else {
-            if (wantColumn.pk) {
-              fail(
-                `${wantTable.table.name}.${wantColumn.name}: Can't add primary key`,
-              );
-            }
-            migration.push(
-              [
-                `alter table ${wantTable.table.name} add column`,
-                wantColumn.name,
-                wantColumn.type,
-                wantColumn.notnull ? "not null" : "",
-                ...wantTable.foreignKeys
-                  .map(({ from, on_delete, on_update, table, to }) =>
-                    from == wantColumn.name
-                      ? `references ${table}(${to}) on delete ${on_delete} on update ${on_update}`
-                      : "",
-                  )
-                  .filter(Boolean),
-              ]
-                .filter(Boolean)
-                .join(" "),
-            );
-          }
-        }
-
-        for (const { from } of wantTable.foreignKeys) {
-          if (
-            from == wantColumn.name &&
-            !haveTable.indices.find(({ info }) => info.name == from)
-          ) {
-            migration.push(
-              `create index ${wantTable.table.name}_${from} on ${wantTable.table.name}(${from})`,
-            );
-          }
-        }
-      }
-      for (const missingColumn of columnsNowMissing) {
-        migration.push(
-          `alter table ${wantTable.table.name} drop column ${missingColumn.name}`,
-        );
-      }
-    } else {
-      if (!wantTable.columns.some(({ pk }) => pk)) {
-        fail(`${wantTable.table.name} has no primary key`);
-      }
-      migration.push(
-        `create table ${wantTable.table.name} (\n` +
-          wantTable.columns
-            .map(({ name, notnull, pk, type }) =>
-              [
-                name,
-                type,
-                pk ? "primary key" : "",
-                !pk && notnull ? "not null" : "",
-                ...wantTable.foreignKeys
-                  .map(({ from, on_delete, on_update, table, to }) =>
-                    from == name
-                      ? `references ${table}(${to}) on delete ${on_delete} on update ${on_update}`
-                      : "",
-                  )
-                  .filter(Boolean),
-              ]
-                .filter(Boolean)
-                .join(" "),
-            )
-            .join(",\n") +
-          `)`,
-      );
-      for (const { from } of wantTable.foreignKeys) {
-        migration.push(
-          `create index ${wantTable.table.name}_${from} on ${wantTable.table.name}(${from})`,
-        );
-      }
-    }
-  }
-
-  for (const haveTable of haveTables) {
-    const wantTable = wantTables.find(
-      ({ table }) => table.name == haveTable.table.name,
-    );
-    if (!wantTable) {
-      migration.push(`drop table ${haveTable.table.name}`);
-    }
-  }
-
-  for (const sql of migration) {
-    database.exec(sql);
-  }
-
-  return /** @type {any} */ (
-    Object.fromEntries(
-      Object.entries(schema).map(([maybeTable]) => {
-        const table = /** @type {keyof typeof schema & string} */ (maybeTable);
-
-        /** @param {{ [K in keyof (typeof schema)[typeof table]["entries"]]?: import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]> | import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]>[]; }} where */
-        function ensureArrayRecord(where) {
-          for (const key of Object.keys(where)) {
-            if (!Array.isArray(where[key])) {
-              Object.assign(where, { [key]: [where[key]] });
-            }
-          }
-        }
-
-        return [
-          table,
-          {
-            /** @param {{ [K in keyof (typeof schema)[typeof table]["entries"]]?: import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]> | import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]>[]; }} where */
-            delete(where) {
-              ensureArrayRecord(where);
-              database
-                .prepare(
-                  `delete from ${table} where true\n` +
-                    Object.entries(where)
-                      .map(
-                        ([name, values]) =>
-                          `and ${name} in (${values.map(() => "?").join(", ")})`,
-                      )
-                      .join("\n"),
-                )
-                .run(
-                  ...Object.values(where)
-                    .flatMap((values) => values)
-                    .map((value) => value ?? null),
-                );
-            },
-
-            /** @param {any} join */
-            select(join) {
-              return select({ database, flat, join, schema, table });
-            },
-
-            /** @param {{ set: Partial<import("valibot").InferOutput<(typeof schema)[typeof table]>>, where: { [K in keyof (typeof schema)[typeof table]["entries"]]?: import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]> | import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]>[]; } }} props */
-            update({ set, where }) {
-              ensureArrayRecord(where);
-              database
-                .prepare(
-                  `update ${table} set\n` +
-                    Object.keys(set)
-                      .map((name) => `${name} = ?`)
-                      .join(",\n") +
-                    `\nwhere true\n` +
-                    Object.entries(where)
-                      .map(
-                        ([name, values]) =>
-                          `and ${name} in (${values.map(() => "?").join(", ")})`,
-                      )
-                      .join("\n"),
-                )
-                .run(
-                  ...[
-                    ...Object.values(set).map((value) => value ?? null),
-                    ...Object.values(where)
-                      .flatMap((values) => values)
-                      .map((value) => value ?? null),
-                  ],
-                );
-            },
-
-            /** @param {any[]} values */
-            upsert(...values) {
-              ok(schema[table]);
-              const columns = Object.entries(schema[table].entries);
-              const primaryKey = columns.find(
-                ([, column]) =>
-                  /** @type {{ primary?: true }} */ (getMetadata(column))
-                    .primary,
-              );
-              ok(primaryKey);
-              const query = database.prepare(
-                `insert into ${table} (${columns.map(([name]) => name).join(", ")}) values\n` +
-                  `(${columns.map(() => "?").join(", ")})\n` +
-                  `on conflict (${primaryKey[0]}) do update set\n` +
-                  columns.map(([name]) => `${name} = ?`).join(",\n"),
-              );
-              const outputs = [];
-              for (const row of values) {
-                const output = parse(schema[table], row);
-                const values = columns.map(([name]) => output[name] ?? null);
-                query.run(...values, ...values);
-                outputs.push(output);
-              }
-              return outputs;
-            },
-          },
-        ];
-      }),
-    )
-  );
-}
-
-/** @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>; 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 columns = Object.keys(
-    /** @type {any} */ (props.schema)[props.table].entries,
-  ).map((name) => `${alias}.${name} ${alias}_${name}`);
-
-  /** @type {Record<string, { entities: any[]; table: string }>} */
-  const aliases = {};
-  /**
-   * @param {number} unique
-   * @param {string} table
-   * @param {string} alias
-   * @param {{ with: any }} ownJoin // eslint-disable-line @typescript-eslint/no-explicit-any
-   */
-  function join(unique, table, alias, ownJoin) {
-    if (!aliases[alias]) {
-      aliases[alias] = { entities: [], table };
-    }
-    for (const [name, itsJoin] of ownJoin ? Object.entries(ownJoin.with) : []) {
-      const otherFlat = props.flat[table];
-      ok(otherFlat);
-      const relation = otherFlat[/** @type {keyof typeof otherFlat} */ (name)];
-      ok(relation);
-
-      const { Its, Other, Own } =
-        /** @type {{ Its: string, Other: string, Own: string }} */ (
-          /** @type {any} */ (relation)
-        );
-      const otherAlias = `${name}_${unique + 1}`;
-      if (!aliases[otherAlias]) {
-        aliases[otherAlias] = { entities: [], table: Other };
-      }
-      columns = [
-        ...columns,
-
-        ...Object.keys(/** @type {any} */ (props.schema)[Other].entries).map(
-          (name) => `${otherAlias}.${name} ${otherAlias}_${name}`,
-        ),
-      ];
-      sql += `\n left join ${Other} ${otherAlias} on ${otherAlias}.${Its} = ${alias}.${Own}`;
-      if (typeof itsJoin == "object") {
-        ok(itsJoin);
-        join(unique + 1, Other, otherAlias, itsJoin);
-      }
-    }
-  }
-
-  join(0, props.table, alias, /** @type {any} */ (props.join));
-  sql = `select ${columns.join(",\n")} ${sql}`;
-
-  const rows = props.database.prepare(sql).all();
-  for (const [alias, state] of Object.entries(aliases)) {
-    /** @type {Record<string, (typeof state.entities)[0]>} */
-    const unique = {};
-    for (const row of rows) {
-      /** @type {Record<string, any>} */
-      const unwrapped = {};
-
-      let empty = true;
-      for (const name of Object.keys(
-        /** @type {any} */ (props.schema)[state.table].entries,
-      )) {
-        unwrapped[name] = row[`${alias}_${name}`] ?? undefined;
-        if (unwrapped[name] !== undefined) {
-          empty = false;
-        }
-      }
-      if (!empty) {
-        unique[JSON.stringify(unwrapped)] = unwrapped;
-      }
-    }
-    state.entities = Object.values(unique);
-  }
-
-  alias = `${props.table}_0`;
-  /**
-   * @param {number} unique
-   * @param {string} table
-   * @param {string} alias
-   * @param {{ with: any }} ownJoin // eslint-disable-line @typescript-eslint/no-explicit-any
-   */
-  function merge(unique, table, alias, ownJoin) {
-    ok(aliases[alias]);
-    for (const [name, itsJoin] of ownJoin ? Object.entries(ownJoin.with) : []) {
-      const otherFlat = props.flat[table];
-      ok(otherFlat);
-      const relation = otherFlat[/** @type {keyof typeof otherFlat} */ (name)];
-      ok(relation);
-
-      const { Its, Other, Own, type } =
-        /** @type {{ Its: string, Other: string, Own: string, type: "referencedBy" | "references" }} */ (
-          /** @type {any} */ (relation)
-        );
-      const otherAlias = `${name}_${unique + 1}`;
-      ok(aliases[otherAlias]?.entities);
-      for (const self of aliases[alias].entities) {
-        const matchingOthers = aliases[otherAlias].entities.filter(
-          (other) => other[Its] == self[Own],
-        );
-        self[name] = type == "references" ? matchingOthers[0] : matchingOthers;
-      }
-      if (typeof itsJoin == "object") {
-        ok(itsJoin);
-        merge(unique + 1, Other, otherAlias, itsJoin);
-      }
-    }
-  }
-
-  merge(0, props.table, alias, /** @type {any} */ (props.join));
-  const state = aliases[alias];
-  ok(state);
-  return state.entities;
-}
+import envPaths from "env-paths";
+import { fail, ok } from "node:assert/strict";
+import { mkdirSync } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+import { getMetadata, parse } from "valibot";
+
+import { flatten, relations } from "./db.js";
+
+/**
+ * @typedef Column
+ * @property {string} name
+ * @property {0 | 1} notnull
+ * @property {0 | 1} pk
+ * @property {"INTEGER" | "TEXT"} type
+ */
+
+/** @type {typeof import("./sqlite.d.ts").sqlite} */
+export function sqlite({ pkg, schema }) {
+  const data = pkg
+    ? (() => {
+        const { data } = envPaths(pkg.name);
+        mkdirSync(data, { recursive: true });
+        return data;
+      })()
+    : undefined;
+  const database = new DatabaseSync(data ? `${data}/db.sqlite3` : ":memory:", {
+    timeout: 1000,
+  });
+  const flat = flatten(relations(schema));
+
+  const haveTables = /** @type {{ name: string }[]} */ (
+    database
+      .prepare(
+        "select * from sqlite_schema where type='table' and name not like 'sqlite_%'",
+      )
+      .all()
+  ).map((table) => {
+    const columns = /** @type {Column[]} */ (
+      database.prepare(`pragma table_info(${table.name})`).all()
+    );
+    const foreignKeys =
+      /** @type {{ from: string, on_delete: "CASCADE" | "SET NULL", on_update: "CASCADE" | "SET NULL", table: string, to: string, }[]} */ (
+        database.prepare(`pragma foreign_key_list(${table.name})`).all()
+      );
+    return {
+      columns,
+      foreignKeys,
+      indices: /** @type {{ name: string }[]} */ (
+        database.prepare(`pragma index_list(${table.name})`).all()
+      )
+        .filter(({ name }) => !/^sqlite_/.test(name))
+        .map((index) => ({
+          ...index,
+          info: /** @type {{ name: string; }} */ (
+            database.prepare(`pragma index_info(${index.name})`).get()
+          ),
+        })),
+      table,
+    };
+  });
+
+  const wantTables = Object.entries(schema).map(([name, { entries }]) => ({
+    columns: Object.entries(entries).map(([name, maybeEntry]) => {
+      const entry =
+        /** @type {import("valibot").BaseSchema<undefined, undefined, any>} */ (
+          maybeEntry
+        );
+      const pk = /** @type {{ primary?: true }} */ (getMetadata(entry)).primary
+        ? 1
+        : 0;
+      return {
+        name,
+        notnull: !pk && entry.expects.includes("undefined") ? 0 : 1,
+        pk,
+        type:
+          entry.expects == "string" || entry.expects == "(string | undefined)"
+            ? "TEXT"
+            : entry.expects == "number" ||
+                entry.expects == "(number | undefined)"
+              ? "INTEGER"
+              : entry.expects == "Uint8Array" ||
+                  entry.expects == "(Uint8Array | undefined)"
+                ? "BLOB"
+                : fail(name),
+      };
+    }),
+    foreignKeys: Object.entries(entries)
+      .map(([name, maybeEntry]) => {
+        const entry =
+          /** @type {import("valibot").BaseSchema<undefined, undefined, any>} */ (
+            maybeEntry
+          );
+
+        const metadata =
+          /** @type {{ key?: string, references?: any } | undefined} */ (
+            getMetadata(entry)
+          );
+        const table = metadata
+          ? Object.entries(schema)
+              .filter(([, value]) => value == metadata.references)
+              .find(Boolean)
+          : undefined;
+        if (!metadata?.references) {
+          return;
+        }
+        ok(table);
+        const to = Object.entries(table[1].entries).find(
+          ([, value]) => value == metadata.key,
+        );
+        ok(to);
+        return {
+          from: name,
+          on_delete: /undefined/.test(entry.expects) ? "SET NULL" : "CASCADE",
+          on_update: /undefined/.test(entry.expects) ? "SET NULL" : "CASCADE",
+          table: table[0],
+          to: to[0],
+        };
+      })
+      .filter(Boolean)
+      .map((x) => {
+        ok(x);
+        return x;
+      }),
+    table: { name },
+  }));
+
+  const migration = [];
+
+  for (const wantTable of wantTables) {
+    const haveTable = haveTables.find(
+      ({ table }) => table.name == wantTable.table.name,
+    );
+    if (haveTable) {
+      for (const { info, name } of haveTable.indices) {
+        if (!wantTable.foreignKeys.find(({ from }) => from == info.name)) {
+          migration.push(`drop index ${name}`);
+        }
+      }
+      const haveColumns = haveTable.columns;
+      const columnsNowMissing = haveColumns.filter(
+        (haveColumn) =>
+          !wantTable.columns.find(({ name }) => name == haveColumn.name),
+      );
+      for (const { name, pk } of columnsNowMissing) {
+        if (pk) {
+          fail(`${haveTable.table.name}.${name}: Can't drop primary key`);
+        }
+      }
+      for (const wantColumn of wantTable.columns) {
+        const haveColumn = haveColumns.find(
+          ({ name }) => name == wantColumn.name,
+        );
+
+        /** @param {Column} column */
+        function checkConstraint(column) {
+          ok(column);
+          ok(haveTable);
+          if (column.pk != wantColumn.pk) {
+            fail(
+              `${haveTable.table.name}.${column.name}: Can't toggle primary key`,
+            );
+          }
+          if (
+            !wantColumn.pk && // Without this condition I get an error with real database created by drizzle-kit.
+            column.notnull != wantColumn.notnull
+          ) {
+            fail(
+              `${haveTable.table.name}.${column.name}: Can't toggle optional`,
+            );
+          }
+        }
+
+        if (haveColumn) {
+          checkConstraint(haveColumn);
+        } else {
+          const renamedColumn = columnsNowMissing.find(
+            ({ notnull, type }) =>
+              wantColumn.type == type && wantColumn.notnull == notnull,
+          );
+          if (renamedColumn) {
+            checkConstraint(renamedColumn);
+            columnsNowMissing.splice(
+              columnsNowMissing.indexOf(renamedColumn),
+              1,
+            );
+            migration.push(
+              `alter table ${wantTable.table.name} rename column ${renamedColumn.name} to ${wantColumn.name}`,
+            );
+          } else {
+            if (wantColumn.pk) {
+              fail(
+                `${wantTable.table.name}.${wantColumn.name}: Can't add primary key`,
+              );
+            }
+            migration.push(
+              [
+                `alter table ${wantTable.table.name} add column`,
+                wantColumn.name,
+                wantColumn.type,
+                wantColumn.notnull ? "not null" : "",
+                ...wantTable.foreignKeys
+                  .map(({ from, on_delete, on_update, table, to }) =>
+                    from == wantColumn.name
+                      ? `references ${table}(${to}) on delete ${on_delete} on update ${on_update}`
+                      : "",
+                  )
+                  .filter(Boolean),
+              ]
+                .filter(Boolean)
+                .join(" "),
+            );
+          }
+        }
+
+        for (const { from } of wantTable.foreignKeys) {
+          if (
+            from == wantColumn.name &&
+            !haveTable.indices.find(({ info }) => info.name == from)
+          ) {
+            migration.push(
+              `create index ${wantTable.table.name}_${from} on ${wantTable.table.name}(${from})`,
+            );
+          }
+        }
+      }
+      for (const missingColumn of columnsNowMissing) {
+        migration.push(
+          `alter table ${wantTable.table.name} drop column ${missingColumn.name}`,
+        );
+      }
+    } else {
+      if (!wantTable.columns.some(({ pk }) => pk)) {
+        fail(`${wantTable.table.name} has no primary key`);
+      }
+      migration.push(
+        `create table ${wantTable.table.name} (\n` +
+          wantTable.columns
+            .map(({ name, notnull, pk, type }) =>
+              [
+                name,
+                type,
+                pk ? "primary key" : "",
+                !pk && notnull ? "not null" : "",
+                ...wantTable.foreignKeys
+                  .map(({ from, on_delete, on_update, table, to }) =>
+                    from == name
+                      ? `references ${table}(${to}) on delete ${on_delete} on update ${on_update}`
+                      : "",
+                  )
+                  .filter(Boolean),
+              ]
+                .filter(Boolean)
+                .join(" "),
+            )
+            .join(",\n") +
+          `)`,
+      );
+      for (const { from } of wantTable.foreignKeys) {
+        migration.push(
+          `create index ${wantTable.table.name}_${from} on ${wantTable.table.name}(${from})`,
+        );
+      }
+    }
+  }
+
+  for (const haveTable of haveTables) {
+    const wantTable = wantTables.find(
+      ({ table }) => table.name == haveTable.table.name,
+    );
+    if (!wantTable) {
+      migration.push(`drop table ${haveTable.table.name}`);
+    }
+  }
+
+  for (const sql of migration) {
+    database.exec(sql);
+  }
+
+  return /** @type {any} */ (
+    Object.fromEntries(
+      Object.entries(schema).map(([maybeTable]) => {
+        const table = /** @type {keyof typeof schema & string} */ (maybeTable);
+
+        /** @param {{ [K in keyof (typeof schema)[typeof table]["entries"]]?: import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]> | import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]>[]; }} where */
+        function ensureArrayRecord(where) {
+          for (const key of Object.keys(where)) {
+            if (!Array.isArray(where[key])) {
+              Object.assign(where, { [key]: [where[key]] });
+            }
+          }
+        }
+
+        return [
+          table,
+          {
+            /** @param {{ [K in keyof (typeof schema)[typeof table]["entries"]]?: import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]> | import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]>[]; }} where */
+            delete(where) {
+              ensureArrayRecord(where);
+              database
+                .prepare(
+                  `delete from ${table} where true\n` +
+                    Object.entries(where)
+                      .map(
+                        ([name, values]) =>
+                          `and ${name} in (${values.map(() => "?").join(", ")})`,
+                      )
+                      .join("\n"),
+                )
+                .run(
+                  ...Object.values(where)
+                    .flatMap((values) => values)
+                    .map((value) => value ?? null),
+                );
+            },
+
+            /** @param {any} join */
+            select(join) {
+              if (join?.where) {
+                ensureArrayRecord(join.where);
+              }
+              return select({ database, flat, join, schema, table });
+            },
+
+            /** @param {{ set: Partial<import("valibot").InferOutput<(typeof schema)[typeof table]>>, where: { [K in keyof (typeof schema)[typeof table]["entries"]]?: import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]> | import("valibot").InferOutput<(typeof schema)[typeof table]["entries"][K]>[]; } }} props */
+            update({ set, where }) {
+              ensureArrayRecord(where);
+              database
+                .prepare(
+                  `update ${table} set\n` +
+                    Object.keys(set)
+                      .map((name) => `${name} = ?`)
+                      .join(",\n") +
+                    `\nwhere true\n` +
+                    Object.entries(where)
+                      .map(
+                        ([name, values]) =>
+                          `and ${name} in (${values.map(() => "?").join(", ")})`,
+                      )
+                      .join("\n"),
+                )
+                .run(
+                  ...[
+                    ...Object.values(set).map((value) => value ?? null),
+                    ...Object.values(where)
+                      .flatMap((values) => values)
+                      .map((value) => value ?? null),
+                  ],
+                );
+            },
+
+            /** @param {any[]} values */
+            upsert(...values) {
+              ok(schema[table]);
+              const columns = Object.entries(schema[table].entries);
+              const primaryKey = columns.find(
+                ([, column]) =>
+                  /** @type {{ primary?: true }} */ (getMetadata(column))
+                    .primary,
+              );
+              ok(primaryKey);
+              const query = database.prepare(
+                `insert into ${table} (${columns.map(([name]) => name).join(", ")}) values\n` +
+                  `(${columns.map(() => "?").join(", ")})\n` +
+                  `on conflict (${primaryKey[0]}) do update set\n` +
+                  columns.map(([name]) => `${name} = ?`).join(",\n"),
+              );
+              const outputs = [];
+              for (const row of values) {
+                const output = parse(schema[table], row);
+                const values = columns.map(([name]) => output[name] ?? null);
+                query.run(...values, ...values);
+                outputs.push(output);
+              }
+              return outputs;
+            },
+          },
+        ];
+      }),
+    )
+  );
+}
+
+/** @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[]} */
+function select(props) {
+  ok(typeof props.table == "string");
+  let alias = `${props.table}_0`;
+  let sql = `from ${props.table} ${alias}`;
+
+  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}`);
+  }
+
+  /** @type {Record<string, { entities: any[]; table: string }>} */
+  const aliases = {};
+  /**
+   * @param {number} unique
+   * @param {string} table
+   * @param {string} alias
+   * @param {{ with: any }} ownJoin // eslint-disable-line @typescript-eslint/no-explicit-any
+   */
+  function join(unique, table, alias, ownJoin) {
+    if (!aliases[alias]) {
+      aliases[alias] = { entities: [], table };
+    }
+    for (const [name, itsJoin] of ownJoin?.with
+      ? Object.entries(ownJoin.with)
+      : []) {
+      const otherFlat = props.flat[table];
+      ok(otherFlat);
+      const relation = otherFlat[/** @type {keyof typeof otherFlat} */ (name)];
+      ok(relation);
+
+      const { Its, Other, Own } =
+        /** @type {{ Its: string, Other: string, Own: string }} */ (
+          /** @type {any} */ (relation)
+        );
+      const otherAlias = `${name}_${unique + 1}`;
+      if (!aliases[otherAlias]) {
+        aliases[otherAlias] = { entities: [], table: Other };
+      }
+      columns = [
+        ...columns,
+
+        ...Object.keys(/** @type {any} */ (props.schema)[Other].entries).map(
+          (name) => `${otherAlias}.${name} ${otherAlias}_${name}`,
+        ),
+      ];
+      sql += `\n left join ${Other} ${otherAlias} on ${otherAlias}.${Its} = ${alias}.${Own}`;
+      if (typeof itsJoin == "object") {
+        ok(itsJoin);
+        join(unique + 1, Other, otherAlias, itsJoin);
+      }
+    }
+  }
+
+  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");
+
+  const rows = props.database.prepare(sql).all(
+    ...Object.values(/** @type {any} */ (props.join)?.where || {})
+      .flatMap((values) => values)
+      .map((value) => value ?? null),
+  );
+  if (!(/** @type {any} */ (props.join)?.with)) {
+    for (const row of rows) {
+      for (const name of Object.keys(row)) {
+        Object.assign(row, { [name]: row[name] ?? undefined });
+      }
+    }
+    return rows;
+  }
+  for (const [alias, state] of Object.entries(aliases)) {
+    /** @type {Record<string, (typeof state.entities)[0]>} */
+    const unique = {};
+    for (const row of rows) {
+      /** @type {Record<string, any>} */
+      const unwrapped = {};
+
+      let empty = true;
+      for (const name of Object.keys(
+        /** @type {any} */ (props.schema)[state.table].entries,
+      )) {
+        unwrapped[name] = row[`${alias}_${name}`] ?? undefined;
+        if (unwrapped[name] !== undefined) {
+          empty = false;
+        }
+      }
+      if (!empty) {
+        unique[JSON.stringify(unwrapped)] = unwrapped;
+      }
+    }
+    state.entities = Object.values(unique);
+  }
+
+  alias = `${props.table}_0`;
+  /**
+   * @param {number} unique
+   * @param {string} table
+   * @param {string} alias
+   * @param {{ with: any }} ownJoin // eslint-disable-line @typescript-eslint/no-explicit-any
+   */
+  function merge(unique, table, alias, ownJoin) {
+    ok(aliases[alias]);
+    for (const [name, itsJoin] of ownJoin?.with
+      ? Object.entries(ownJoin.with)
+      : []) {
+      const otherFlat = props.flat[table];
+      ok(otherFlat);
+      const relation = otherFlat[/** @type {keyof typeof otherFlat} */ (name)];
+      ok(relation);
+
+      const { Its, Other, Own, type } =
+        /** @type {{ Its: string, Other: string, Own: string, type: "referencedBy" | "references" }} */ (
+          /** @type {any} */ (relation)
+        );
+      const otherAlias = `${name}_${unique + 1}`;
+      ok(aliases[otherAlias]?.entities);
+      for (const self of aliases[alias].entities) {
+        const matchingOthers = aliases[otherAlias].entities.filter(
+          (other) => other[Its] == self[Own],
+        );
+        self[name] = type == "references" ? matchingOthers[0] : matchingOthers;
+      }
+      if (typeof itsJoin == "object") {
+        ok(itsJoin);
+        merge(unique + 1, Other, otherAlias, itsJoin);
+      }
+    }
+  }
+
+  merge(0, props.table, alias, /** @type {any} */ (props.join));
+  const state = aliases[alias];
+  ok(state);
+  return state.entities;
+}