evikit 2.9.2 → 2.10.0

package/sqlite.js

@@ -1,576 +1,576 @@
-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,
-  });
-  database.prepare("pragma journal_mode=wal").run();
-  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);
-  }
-
-  /** @type {(({ table }: { table: string }) => void)[]} */
-  const listeners = [];
-  if (process.env["i"]) {
-    process.on("message", (maybeMessage) => {
-      for (const onMessage of listeners) {
-        onMessage(/** @type {any} */ (maybeMessage));
-      }
-    });
-  }
-  /** @param {{ table: string }} message */
-  function publish(message) {
-    Object.assign(message, { i: process.env["i"] });
-    process.send?.(message, undefined, { keepOpen: true });
-    for (const onMessage of listeners) {
-      onMessage(message);
-    }
-  }
-
-  return {
-    .../** @type {any} */ (
-      Object.fromEntries(
-        Object.entries(schema).map(([maybeTable]) => {
-          const table = /** @type {keyof typeof schema & string} */ (
-            maybeTable
-          );
-          ok(schema[table]);
-          const columns = Object.entries(schema[table].entries);
-          const primaryKey = columns.find(
-            ([, column]) =>
-              /** @type {{ primary?: true }} */ (getMetadata(column)).primary,
-          );
-          ok(primaryKey);
-          const upsert = 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"),
-          );
-
-          return [
-            table,
-            {
-              /** @param {import("./db.d.ts").Where<typeof schema, typeof table>} where */
-              delete(where) {
-                if (
-                  database
-                    .prepare(`delete from ${table}` + whereQuery({ where }))
-                    .run(...whereValues(where)).changes
-                ) {
-                  publish({ table });
-                }
-              },
-
-              /** @param {any} join */
-              select(join) {
-                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 }) {
-                if (
-                  database
-                    .prepare(
-                      `update ${table} set\n` +
-                        Object.keys(set)
-                          .map((name) => `${name} = ?`)
-                          .join(",\n") +
-                        whereQuery({ where }),
-                    )
-                    .run(
-                      ...[
-                        ...Object.values(set).map((value) => value ?? null),
-                        ...whereValues(where),
-                      ],
-                    ).changes
-                ) {
-                  publish({ table });
-                }
-              },
-
-              /** @param {any[]} values */
-              upsert(...values) {
-                ok(schema[table]);
-                const outputs = [];
-                /** @type {boolean} */
-                let changes = false;
-                for (const row of values) {
-                  const output = parse(schema[table], row);
-                  const values = columns.map(([name]) => output[name] ?? null);
-                  if (upsert.run(...values, ...values).changes) {
-                    changes = true;
-                  }
-                  outputs.push(output);
-                }
-                if (changes) {
-                  publish({ table });
-                }
-                return outputs;
-              },
-            },
-          ];
-        }),
-      )
-    ),
-    schema,
-    subscribe(onMessage) {
-      listeners.push(onMessage);
-      return () => {
-        listeners.splice(listeners.indexOf(onMessage), 1);
-      };
-    },
-  };
-}
-
-/** @type {<Schema extends Record<string, import("valibot").ObjectSchema<any, any>>, R extends import("./db.d.ts").Relations<Schema> = import("./db.d.ts").Relations<Schema>, F extends import("./db.d.ts").Flatten<Schema> = import("./db.d.ts").Flatten<Schema>, Table extends keyof F & keyof Schema = keyof F & keyof Schema >(props: { database: DatabaseSync; flat: F; join?: import("./db.d.ts").Join<R, Table> & { where?: import("./db.d.ts").Where<Schema, Table> }; schema: Schema; table: Table; }) => any[]} */
-function select(props) {
-  ok(typeof props.table == "string");
-  let alias = `${props.table}_0`;
-  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}` +
-    whereQuery({ alias, where: props.join?.where });
-
-  const rows = props.database
-    .prepare(sql)
-    .all(...whereValues(props.join?.where));
-  if (!(/** @type {any} */ (props.join)?.with)) {
-    for (const row of rows) {
-      for (const name of Object.keys(row)) {
-        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;
-}
-
-/** @param {{ alias?: string, where: import("./db.js").Where<any, string> | undefined }} props */
-function whereQuery({ alias, where }) {
-  return (
-    "\nwhere true\n" +
-    Object.entries(where || {})
-      .map(([name, values]) => {
-        if (alias) {
-          name = `${alias}.${name}`;
-        }
-        return Array.isArray(values)
-          ? `and ${name} in (${values.map(() => "?").join(", ")})`
-          : typeof values == "number" || typeof values == "string"
-            ? `and ${name} = ?`
-            : Object.keys(values)
-                .map(
-                  (operator) =>
-                    `and ${name} ` +
-                    (operator == "gt"
-                      ? ">"
-                      : operator == "gte"
-                        ? ">="
-                        : operator == "lt"
-                          ? "<"
-                          : operator == "lte"
-                            ? "<="
-                            : "!=") +
-                    " ?",
-                )
-                .join("");
-      })
-      .join("\n")
-  );
-}
-
-/** @param {import("./db.js").Where<any, string> | undefined} where */
-function whereValues(where) {
-  return Object.values(where || {})
-    .flatMap((values) =>
-      Array.isArray(values)
-        ? values
-        : typeof values == "number" || typeof values == "string"
-          ? values
-          : Object.values(values),
-    )
-    .map((value) => value ?? null);
-}
+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,
+  });
+  database.prepare("pragma journal_mode=wal").run();
+  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);
+  }
+
+  /** @type {(({ table }: { table: string }) => void)[]} */
+  const listeners = [];
+  if (process.env["i"]) {
+    process.on("message", (maybeMessage) => {
+      for (const onMessage of listeners) {
+        onMessage(/** @type {any} */ (maybeMessage));
+      }
+    });
+  }
+  /** @param {{ table: string }} message */
+  function publish(message) {
+    Object.assign(message, { i: process.env["i"] });
+    process.send?.(message, undefined, { keepOpen: true });
+    for (const onMessage of listeners) {
+      onMessage(message);
+    }
+  }
+
+  return {
+    .../** @type {any} */ (
+      Object.fromEntries(
+        Object.entries(schema).map(([maybeTable]) => {
+          const table = /** @type {keyof typeof schema & string} */ (
+            maybeTable
+          );
+          ok(schema[table]);
+          const columns = Object.entries(schema[table].entries);
+          const primaryKey = columns.find(
+            ([, column]) =>
+              /** @type {{ primary?: true }} */ (getMetadata(column)).primary,
+          );
+          ok(primaryKey);
+          const upsert = 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"),
+          );
+
+          return [
+            table,
+            {
+              /** @param {import("./db.d.ts").Where<typeof schema, typeof table>} where */
+              delete(where) {
+                if (
+                  database
+                    .prepare(`delete from ${table}` + whereQuery({ where }))
+                    .run(...whereValues(where)).changes
+                ) {
+                  publish({ table });
+                }
+              },
+
+              /** @param {any} join */
+              select(join) {
+                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 }) {
+                if (
+                  database
+                    .prepare(
+                      `update ${table} set\n` +
+                        Object.keys(set)
+                          .map((name) => `${name} = ?`)
+                          .join(",\n") +
+                        whereQuery({ where }),
+                    )
+                    .run(
+                      ...[
+                        ...Object.values(set).map((value) => value ?? null),
+                        ...whereValues(where),
+                      ],
+                    ).changes
+                ) {
+                  publish({ table });
+                }
+              },
+
+              /** @param {any[]} values */
+              upsert(...values) {
+                ok(schema[table]);
+                const outputs = [];
+                /** @type {boolean} */
+                let changes = false;
+                for (const row of values) {
+                  const output = parse(schema[table], row);
+                  const values = columns.map(([name]) => output[name] ?? null);
+                  if (upsert.run(...values, ...values).changes) {
+                    changes = true;
+                  }
+                  outputs.push(output);
+                }
+                if (changes) {
+                  publish({ table });
+                }
+                return outputs;
+              },
+            },
+          ];
+        }),
+      )
+    ),
+    schema,
+    subscribe(onMessage) {
+      listeners.push(onMessage);
+      return () => {
+        listeners.splice(listeners.indexOf(onMessage), 1);
+      };
+    },
+  };
+}
+
+/** @type {<Schema extends Record<string, import("valibot").ObjectSchema<any, any>>, R extends import("./db.d.ts").Relations<Schema> = import("./db.d.ts").Relations<Schema>, F extends import("./db.d.ts").Flatten<Schema> = import("./db.d.ts").Flatten<Schema>, Table extends keyof F & keyof Schema = keyof F & keyof Schema >(props: { database: DatabaseSync; flat: F; join?: import("./db.d.ts").Join<R, Table> & { where?: import("./db.d.ts").Where<Schema, Table> }; schema: Schema; table: Table; }) => any[]} */
+function select(props) {
+  ok(typeof props.table == "string");
+  let alias = `${props.table}_0`;
+  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}` +
+    whereQuery({ alias, where: props.join?.where });
+
+  const rows = props.database
+    .prepare(sql)
+    .all(...whereValues(props.join?.where));
+  if (!(/** @type {any} */ (props.join)?.with)) {
+    for (const row of rows) {
+      for (const name of Object.keys(row)) {
+        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;
+}
+
+/** @param {{ alias?: string, where: import("./db.js").Where<any, string> | undefined }} props */
+function whereQuery({ alias, where }) {
+  return (
+    "\nwhere true\n" +
+    Object.entries(where || {})
+      .map(([name, values]) => {
+        if (alias) {
+          name = `${alias}.${name}`;
+        }
+        return Array.isArray(values)
+          ? `and ${name} in (${values.map(() => "?").join(", ")})`
+          : typeof values == "number" || typeof values == "string"
+            ? `and ${name} = ?`
+            : Object.keys(values)
+                .map(
+                  (operator) =>
+                    `and ${name} ` +
+                    (operator == "gt"
+                      ? ">"
+                      : operator == "gte"
+                        ? ">="
+                        : operator == "lt"
+                          ? "<"
+                          : operator == "lte"
+                            ? "<="
+                            : "!=") +
+                    " ?",
+                )
+                .join("");
+      })
+      .join("\n")
+  );
+}
+
+/** @param {import("./db.js").Where<any, string> | undefined} where */
+function whereValues(where) {
+  return Object.values(where || {})
+    .flatMap((values) =>
+      Array.isArray(values)
+        ? values
+        : typeof values == "number" || typeof values == "string"
+          ? values
+          : Object.values(values),
+    )
+    .map((value) => value ?? null);
+}