evikit 1.0.0

package/sqlite.js

@@ -0,0 +1,475 @@
+import { fail, ok } from "node:assert/strict";
+import { DatabaseSync } from "node:sqlite";
+import { getMetadata, parse } from "valibot";
+
+import { flatten, relations } from "./db.js";
+
+/** @type {typeof import("./sqlite.d.ts").sqlite} */
+export function sqlite(path, { schema }) {
+  const database = new DatabaseSync(path, { 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 {{ name: string, notnull: 0 | 1, pk: 0 | 1, type: "INTEGER" | "TEXT", }[]} */ (
+        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"
+              : 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 {typeof haveColumn} 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;
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "outDir": "dist",
+    "module": "nodenext",
+    "target": "esnext",
+    "types": [],
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitReturns": true,
+    "noImplicitOverride": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+    "allowJs": true,
+    "checkJs": true,
+    "noEmit": true,
+    "esModuleInterop": true
+  }
+}

package/use-api.d.ts

@@ -0,0 +1,12 @@
+import { type InferOutput, type ObjectSchema } from "valibot";
+
+export function queryApi<T, U extends ObjectSchema<T, undefined>>(props: {
+  lang?: string;
+  origin: string | undefined;
+  path: string;
+  schema?: U;
+}): { queryFn: () => Promise<InferOutput<U>>; queryKey: string[] };
+
+export function useApi<T, U extends ObjectSchema<T, undefined>>(routeType: {
+  outputs: { 200: U };
+}): { data?: InferOutput<U>; error?: unknown };

package/use-api.js

@@ -0,0 +1,46 @@
+import { useRoute } from "preact-iso";
+import { parse } from "valibot";
+
+import { jsdomCookie } from "./jsdom-cookie.js";
+import { useQuery } from "./query.js";
+
+/** @param {{ lang?: string, origin: string | undefined, path: string, schema?: any }} props */
+export function queryApi({ lang, origin, path, schema }) {
+  const queryKey =
+    path == "/" ? ["home"] : path.split("/").slice(1).map(decodeURIComponent);
+
+  return {
+    queryFn: async () => {
+      const response = await fetch(
+        (origin || "") +
+          path.replace(/^\//, "/api/").replace(/^\/api\/$/, "/api"),
+        {
+          headers: {
+            ...(lang ? { "Accept-Language": lang } : {}),
+            Cookie: jsdomCookie.setCookie.join("; "),
+          },
+        },
+      );
+      if (response.status >= 400) {
+        const error = new Error(await response.text());
+        error.name = response.status.toString();
+        throw Error;
+      }
+      const json = await response.json();
+      return schema ? parse(schema, json) : json;
+    },
+    queryKey,
+  };
+}
+
+/** @param {{ outputs: { 200: any } }} routeType */
+export function useApi(routeType) {
+  const { path } = useRoute();
+  const { queryFn, queryKey } = queryApi({
+    origin: location.origin,
+    path,
+    schema: routeType.outputs[200],
+  });
+  const { data, error } = useQuery({ queryFn, queryKey });
+  return { data, error };
+}

package/use-enhance.d.ts

@@ -0,0 +1,19 @@
+import {
+  type InferOutput,
+  type ObjectSchema,
+  type StringSchema,
+} from "valibot";
+
+export function useEnhance<
+  T,
+  U extends ObjectSchema<T, undefined> | StringSchema<undefined>,
+>(
+  schema: { outputs: Record<number, U> },
+  onSuccess?: (output: InferOutput<U>) => void,
+): {
+  busy: boolean;
+  onSubmit: (event: {
+    preventDefault: () => void;
+    target: EventTarget | null;
+  }) => void;
+};

package/use-enhance.js

@@ -0,0 +1,99 @@
+import { useState } from "preact/hooks";
+import { parse } from "valibot";
+
+import { jsdomCookie } from "./jsdom-cookie.js";
+import { useQueryClient } from "./query.js";
+
+/**
+ * @param {{ outputs: Record<number, import("valibot").ObjectSchema<any, undefined> | import("valibot").StringSchema<undefined>> }} schema
+ * @param {(output: any) => any} [onSuccess]
+ */
+export function useEnhance(schema, onSuccess) {
+  const [busy, setBusy] = useState(false);
+  const queryClient = useQueryClient();
+
+  /** @param {{ preventDefault: () => void, target: EventTarget | null }} event */
+  async function onSubmit(event) {
+    event.preventDefault();
+    if (busy) {
+      return;
+    }
+    setBusy(true);
+    const form = /** @type {HTMLFormElement} */ (event.target);
+    let output;
+    try {
+      const body = new URLSearchParams();
+      for (const input of [...form.querySelectorAll("input")]) {
+        if (
+          !input.disabled &&
+          ((input.type != "checkbox" && input.type != "radio") || input.checked)
+        ) {
+          body.append(input.name, input.value);
+        }
+      }
+      for (const select of [...form.querySelectorAll("select")]) {
+        if (!select.disabled) {
+          body.append(select.name, select.value);
+        }
+      }
+      for (const textarea of [...form.querySelectorAll("textarea")]) {
+        if (!textarea.disabled) {
+          body.append(textarea.name, textarea.value);
+        }
+      }
+      const response = await fetch(form.action, {
+        body: body.toString(),
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/x-www-form-urlencoded",
+          Cookie: jsdomCookie.setCookie.join("; "),
+        },
+        method: form.method,
+        redirect: "manual", // Do not follow, just run callback.
+      });
+      const setCookie = response.headers.getSetCookie();
+      if (setCookie.length) {
+        jsdomCookie.setCookie = [...jsdomCookie.setCookie, ...setCookie];
+      }
+      if (response.status >= 400) {
+        throw new Error(await response.text());
+      }
+      const json = await response.json();
+      if (json.opaqueRedirectWorkaround) {
+        const error = new Error(json.opaqueRedirectWorkaround.location);
+        error.name = json.opaqueRedirectWorkaround.status;
+        throw error;
+      }
+      const outputSchema =
+        schema.outputs[
+          json.opaqueRedirectWorkaround?.status || response.status
+        ];
+      if (!outputSchema) {
+        const error = new Error(response.status.toString());
+        error.name = response.status.toString();
+        throw error;
+      }
+      output = parse(outputSchema, json);
+    } catch (e) {
+      const error = /** @type {Error} */ (e);
+      if (error.name == "302") {
+        if (new URL(location.href).pathname != error.message) {
+          location.href = error.message;
+          return;
+        }
+      } else {
+        console.error(error);
+        alert(error.message);
+        return;
+      }
+    } finally {
+      setTimeout(() => {
+        setBusy(false);
+      }, 1e3);
+    }
+    onSuccess?.(output);
+    queryClient.invalidateQueries();
+  }
+
+  return { busy, onSubmit };
+}