ascua-scaffold 0.2.0 → 0.4.0

package/README.md

@@ -54,10 +54,18 @@ y vuelve a generar el módulo de brasa con las consultas nuevas.
   enum, `type="date"` para fechas, `field.email` para una columna que se
   llame `email`, `<textarea>` para `description`, `body` o `notes`. Lo
   nullable es opcional y vacío se guarda como `NULL`.
+- **Relaciones**: una columna con clave foránea (`category_id integer
+  REFERENCES categories`) se elige de un `<select>` con las filas de la otra
+  tabla, por su nombre —la columna `name`, `title`, `email`… que tenga—, y la
+  lista muestra ese nombre en vez del número. Las opciones salen de una
+  consulta generada, `ProductCategoryIdOptions`, que puedes cambiar.
 - **Formularios de HTML**, sin islas: funcionan sin una línea de JavaScript.
   Un error de validación vuelve a la página con un 400, cada mensaje bajo su
-  campo y lo escrito en su sitio. Un `UNIQUE` repetido, con un 409 y el error
-  bajo esa columna, no con un 500.
+  campo y lo escrito en su sitio.
+- **Lo que la base rechaza vuelve al formulario** con un 409, no con un 500:
+  un `UNIQUE` repetido («Already taken.»), una clave foránea que no existe
+  («Does not exist.») y borrar una fila que otras usan («Still used by other
+  rows.»), con el error bajo su columna. En Postgres y en MySQL.
 - **La clave de la URL se valida** antes de llegar a la base: `/products/abc`
   es un 404. Un `bigint` entra como texto, para no perder precisión.
 
@@ -80,14 +88,40 @@ un `<form>` de HTML, así que también funciona sin JavaScript.
   (`ProductForm`) y se guardan todas en una sola transacción
   (`transaction()` de brasa): si una falla, no se escribe ninguna, y el
   error aparece en su celda.
-- Un `UNIQUE` repetido vuelve con un 409 y el error bajo la celda de esa
-  fila.
+- Lo que la base rechaza —un `UNIQUE` repetido, una clave foránea que no
+  existe— vuelve con un 409 y el error en esa fila.
+
+## El admin
+
+```sh
+stil exec ascua-scaffold --admin
+```
+
+Genera todas las tablas a la vez bajo `/admin`, como el admin de Django:
+lista, alta, edición y grilla de cada una, un panel en `/admin` y una barra
+con las tablas.
+
+- **Pide usuario y contraseña** (HTTP Basic): `ADMIN_PASSWORD` y
+  `ADMIN_USER` («admin» por defecto). **Sin `ADMIN_PASSWORD`, `/admin` es un
+  404**: nunca queda abierto por olvido. Va en `src/routes/admin/_middleware.ts`,
+  para cambiarlo por el inicio de sesión del sitio (passkeys, una sesión)
+  cuando lo tenga.
+- **Reutiliza lo que hay**: una tabla que ya tiene sus consultas y su
+  `src/resources/<tabla>.ts` —de un `ascua-scaffold <tabla>` anterior— los
+  conserva y solo recibe sus páginas del admin.
+- **Lo que no puede generar lo salta y dice por qué**: vistas, claves
+  compuestas, columnas obligatorias que el formulario no sabe editar. El
+  panel las lista.
+- **Se puede volver a correr**: tras una migración nueva, agrega las tablas
+  nuevas y deja como están las que ya tenían página. `--force` las reescribe
+  todas.
 
 ## Requisitos
 
 - Un sitio con servidor: `ascua({ site: { mode: "server" } })` en
   `vite.config.ts` (`create-ascua --template server`).
-- `brasa.json` y las migraciones de brasa (`brasa init`).
+- `brasa.json` y las migraciones de brasa (`brasa init`). Las relaciones
+  piden brasa-sql 0.2.0 o más nuevo, que describe las claves foráneas.
 - Una tabla con clave primaria de una sola columna: entero, texto o uuid. Si
   es `serial` o tiene `DEFAULT`, la pone la base; si no, se pide al crear y
   no se cambia al editar.
@@ -97,6 +131,7 @@ un `<form>` de HTML, así que también funciona sin JavaScript.
 
 ```text
 ascua-scaffold <tabla> [--config brasa.json] [--force]
+ascua-scaffold --admin [--config brasa.json] [--force]
 ```
 
 ## Licencia

package/generate.js

@@ -71,7 +71,7 @@ export class ScaffoldError extends Error {}
  * Qué columnas van en cada parte del recurso. Lanza `ScaffoldError` si la
  * tabla no se puede generar.
  */
-export function analizar(tabla, { mysql }) {
+export function analizar(tabla, { mysql, tablas = [] }) {
   if (tabla.view) throw new ScaffoldError(t(`\`${tabla.name}\` es una vista: no se puede editar`, `\`${tabla.name}\` is a view: it cannot be edited`));
   if (tabla.primaryKey.length !== 1) {
     throw new ScaffoldError(
@@ -115,9 +115,33 @@ export function analizar(tabla, { mysql }) {
   if (alEditar.length === 0) throw new ScaffoldError(t(`\`${tabla.name}\` no tiene columnas que editar`, `\`${tabla.name}\` has no columns to edit`));
 
   const visibles = tabla.columns.filter((c) => c !== clave && EDITABLES.has(c.kind) && !c.array).slice(0, 4);
-  return { clave, claveAutomatica, alCrear, alEditar, fuera, visibles, mysql };
+
+  // Las columnas que apuntan a otra tabla se eligen de una lista.
+  const relaciones = [];
+  for (const c of alCrear) {
+    const destino = c.references && tablas.find((x) => x.name === c.references.table);
+    if (!destino) continue;
+    relaciones.push({ columna: c, tabla: destino.name, valor: c.references.column, etiqueta: etiquetaDe(destino, c.references.column) });
+  }
+  return { clave, claveAutomatica, alCrear, alEditar, fuera, visibles, relaciones, mysql };
+}
+
+/** Las columnas que se prefieren para nombrar una fila de otra tabla. */
+const ROTULOS = ["name", "title", "label", "full_name", "display_name", "username", "email", "code", "slug"];
+
+/** Con qué columna se muestra una fila de `tabla` en una lista: su nombre, si tiene, o la clave. */
+function etiquetaDe(tabla, valor) {
+  const texto = tabla.columns.filter((c) => c.kind === "text" && !c.array);
+  const preferida = ROTULOS.map((r) => texto.find((c) => c.name.toLowerCase() === r)).find(Boolean);
+  return (preferida ?? texto.find((c) => c.name !== valor) ?? { name: valor }).name;
 }
 
+/** La relación de una columna, si apunta a otra tabla. */
+const relacionDe = (a, c) => a.relaciones.find((r) => r.columna === c);
+
+/** El nombre de la consulta con las opciones de una columna: ProductCategoryIdOptions. */
+export const consultaOpciones = (n, r) => `${n.uno}${pascal(r.columna.name)}Options`;
+
 /** Los nombres de las consultas del recurso. */
 export function nombres(tabla) {
   const plural = pascal(tabla.name);
@@ -154,7 +178,14 @@ export function consultasSql(tabla, a, n) {
     `-- name: ${n.get} :one\nSELECT * FROM ${tab} WHERE ${pk} = :${a.clave.name};\n\n` +
     `${crear}\n\n` +
     actualizar +
-    `-- name: ${n.delete} :execrows\nDELETE FROM ${tab} WHERE ${pk} = :${a.clave.name};\n`
+    `-- name: ${n.delete} :execrows\nDELETE FROM ${tab} WHERE ${pk} = :${a.clave.name};\n` +
+    a.relaciones
+      .map(
+        (r) =>
+          `\n-- name: ${consultaOpciones(n, r)} :many\n-- The choices for ${r.columna.name}, by ${r.etiqueta}.\n` +
+          `SELECT ${q(r.valor)} AS value, ${q(r.etiqueta)} AS label FROM ${q(r.tabla)}\nORDER BY ${q(r.etiqueta)}\nLIMIT 1000;\n`,
+      )
+      .join("")
   );
 }
 
@@ -183,14 +214,23 @@ function campo(c, valoresEnum) {
 }
 
 /** El control HTML de una columna, dentro del `view` de `…Fields`. */
-function control(c, valoresEnum) {
+function control(c, valoresEnum, relacion) {
   const nombre = c.name;
   const v = `values${acceso(nombre)}`;
   const texto = `String(${v} ?? "")`;
   // El esquema exige todo lo NOT NULL salvo casillas y texto con DEFAULT (que acepta vacío).
   const req = !c.nullable && c.kind !== "boolean" && !(c.kind === "text" && c.hasDefault) ? " required" : "";
   let html;
-  switch (c.kind) {
+  switch (relacion ? "relacion" : c.kind) {
+    case "relacion": {
+      const vacia = c.nullable ? `<option value=""></option>` : `<option value="" disabled prop:selected=\${!${v}}>Choose…</option>`;
+      html =
+        `<select name="${nombre}"${req}>${vacia}\n` +
+        `          <For each=\${() => props.options${acceso(nombre)}} key=\${(o: Option) => o.value}\n` +
+        `               render=\${(o: Option) => view\`<option value=\${o.value} prop:selected=\${${v} === o.value}>\${o.label}</option>\`}/>\n` +
+        `        </select>`;
+      break;
+    }
     case "boolean":
       html = `<input type="checkbox" name="${nombre}" prop:checked=\${${v} === "on"}>`;
       break;
@@ -246,26 +286,42 @@ function aTexto(c, fila) {
 }
 
 /**
- * `duplicate()` del recurso: un UNIQUE o una clave repetidos vuelven al
- * formulario con un 409 en vez de un 500. Postgres dice la columna en el
- * `detail`; MySQL da el nombre del índice, así que ahí el error es general.
+ * `rejected()` del recurso: lo que la base rechaza por una restricción vuelve
+ * al formulario con un 409 y el error bajo su columna, en vez de un 500. Un
+ * UNIQUE repetido, una clave foránea que no existe y borrar algo que otras
+ * filas usan. Postgres dice la columna en el `detail`; MySQL, en el mensaje
+ * de la clave foránea, y en un UNIQUE solo el índice: ahí el error es general.
  */
 function duplicado(mysql) {
   const deteccion = mysql
-    ? `  if (e?.code !== "ER_DUP_ENTRY") throw error;
-  const field = "";`
-    : `  if (e?.code !== "23505") throw error;
-  // "Key (sku)=(H-1) already exists."
-  const column = /^Key \\(([^)]+)\\)=/.exec(String(e.detail))?.[1];
-  const field = column && !column.includes(",") ? column : "";`;
+    ? `  const code = e?.code;
+  // "… FOREIGN KEY (\`supplier_id\`) REFERENCES …"
+  const column = /FOREIGN KEY \\(\`([^\`]+)\`\\)/.exec(String(e?.message))?.[1] ?? "";
+  if (code === "ER_DUP_ENTRY") return reject("", "Already taken.");
+  if (code === "ER_NO_REFERENCED_ROW_2") return reject(column, "Does not exist.");
+  if (code === "ER_ROW_IS_REFERENCED_2") return reject("", "Still used by other rows.");
+  throw error;`
+    : `  // "Key (sku)=(H-1) already exists.", "Key (supplier_id)=(9) is not present in table …"
+  const named = /^Key \\(([^)]+)\\)=/.exec(String(e?.detail))?.[1];
+  const column = named && !named.includes(",") ? named : "";
+  if (e?.code === "23505") return reject(column, "Already taken.");
+  if (e?.code === "23503") {
+    // Deleting a row that others point to says "still referenced".
+    if (/still referenced/.test(String(e.detail))) return reject("", "Still used by other rows.");
+    return reject(column, "Does not exist.");
+  }
+  throw error;`;
   return `/**
- * A duplicate of a UNIQUE column or of the key, as the same form again with
- * the error under that field (409). Any other error is thrown again.
+ * What the database rejected because of a constraint, as the same form again
+ * with the error under its field (409): a repeated UNIQUE value, a key of
+ * another table that does not exist, deleting a row others still use. Any
+ * other error is thrown again.
  */
-export function duplicate(error: unknown, formData: FormData) {
-  const e = error as { code?: unknown; detail?: unknown } | null;
+export function rejected(error: unknown, formData: FormData) {
+  const e = error as { code?: unknown; detail?: unknown; message?: unknown } | null;
+  const reject = (field: string, message: string) =>
+    fail(409, { ok: false as const, errors: { [field]: message }, values: texts(formData) });
 ${deteccion}
-  return fail(409, { ok: false as const, errors: { [field]: "Already taken." }, values: texts(formData) });
 }
 
 /** The text fields of a form, to fill it in again. */
@@ -285,7 +341,30 @@ export function recurso(tabla, a, n, { db, enums }) {
   const conClave = !a.claveAutomatica;
 
   const esquema = a.alEditar.map((c) => `  ${propiedad(c.name)}: ${campo(c, valoresEnum(c))},`).join("\n");
-  const controles = (cols) => cols.map((c) => control(c, valoresEnum(c))).join("\n");
+  const controles = (cols) => cols.map((c) => control(c, valoresEnum(c), relacionDe(a, c))).join("\n");
+  const funcionesOpciones = a.relaciones.map((r) => camel(consultaOpciones(n, r)));
+  const opciones = a.relaciones.length
+    ? `
+/** The choices of the columns that point to other tables, as text. */
+export async function ${camel(n.uno)}Options(db: Queryable): Promise<Options> {
+  const [${a.relaciones.map((r) => camel(r.columna.name)).join(", ")}] = await Promise.all([
+${funcionesOpciones.map((f) => `    ${f}(db),`).join("\n")}
+  ]);
+  const text = (rows: { value: unknown; label: unknown }[]) => rows.map((o) => ({ value: String(o.value), label: String(o.label ?? o.value) }));
+  return {
+${a.relaciones.map((r) => `    ${propiedad(r.columna.name)}: text(${camel(r.columna.name)}),`).join("\n")}
+  };
+}
+`
+    : `
+/** The choices of the columns that point to other tables: ${tabla.name} has none. */
+export async function ${camel(n.uno)}Options(_db: Queryable): Promise<Options> {
+  return {};
+}
+`;
+  const tipoOpciones = a.relaciones.length
+    ? `{ ${a.relaciones.map((r) => `${propiedad(r.columna.name)}: Option[]`).join("; ")} }`
+    : "Record<string, never>";
   const aParams = a.alEditar
     .map((c) => {
       const v = `data${acceso(c.name)}`;
@@ -326,7 +405,7 @@ export const New${n.uno}Form = ${n.uno}Form;
 import type { Infer } from "ascua";
 import { fail, field, fields } from "vite-plugin-ascua/site";
 
-import { ${[...importsEnum, `type ${n.get}Row`].join(", ")} } from "${db}";
+import { ${[...importsEnum, ...funcionesOpciones, "type Queryable", `type ${n.get}Row`].join(", ")} } from "${db}";
 
 const shape = {
 ${esquema}
@@ -338,6 +417,9 @@ ${nuevoEsquema}
 export type ${n.uno}Data = Infer<typeof ${n.uno}Form>;
 export type FormValues = Partial<Record<string, string | string[]>>;
 export type FormErrors = Partial<Record<string, string>>;
+/** One choice of a <select>: the value it sends and what it shows. */
+export type Option = { value: string; label: string };
+export type Options = ${tipoOpciones};
 ${fechas}
 /** The form data as query parameters: empty optional fields become NULL. */
 export function ${camel(n.uno)}Params(data: ${n.uno}Data) {
@@ -346,7 +428,7 @@ ${aParams}
   };
 }
 
-${duplicado(a.mysql)}
+${duplicado(a.mysql)}${opciones}
 /** A row as the values of the form. */
 export function ${camel(n.uno)}Values(row: ${n.get}Row): FormValues {
   return {
@@ -355,7 +437,7 @@ ${aValores}
 }
 
 /** The fields of the form, with the error of each one under it. */
-export function ${n.uno}Fields(props: { values: FormValues; errors: FormErrors${conClave ? "; withKey?: boolean" : ""} }) {
+export function ${n.uno}Fields(props: { values: FormValues; errors: FormErrors; options: Options${conClave ? "; withKey?: boolean" : ""} }) {
   const { values, errors } = props;
   return view\`
     <div class="fields">
@@ -393,16 +475,21 @@ export function rutas(tabla, a, n, { db, pool, resource, base }) {
   const params = `${camel(n.uno)}Params`;
   const values = `${camel(n.uno)}Values`;
   const campos = `${n.uno}Fields`;
+  const opcionesFn = `${camel(n.uno)}Options`;
 
   const cabeceras = [pk, ...a.visibles.map((c) => c.name)].map((c) => `<th>${etiqueta(c)}</th>`).join("");
-  const celdas = a.visibles.map((c) => `<td>\${show(r${acceso(c.name)})}</td>`).join("");
+  // Una columna que apunta a otra tabla se lee por su nombre, no por su clave.
+  const conOpciones = a.visibles.some((c) => relacionDe(a, c));
+  const celdas = a.visibles
+    .map((c) => (relacionDe(a, c) ? `<td>\${label(data.options${acceso(c.name)}, r${acceso(c.name)})}</td>` : `<td>\${show(r${acceso(c.name)})}</td>`))
+    .join("");
 
   const index = `// Generated by ascua-scaffold. Yours to edit: it is not generated again.
 import type { LoadContext } from "vite-plugin-ascua/site";
 
 import { ${camel(n.list)}, type ${n.list}Row } from "${db.index}";
 import { db } from "${pool.index}";
-
+${conOpciones ? `import { ${opcionesFn}, type Option } from "${resource.nested}";\n` : ""}
 const PAGE = 50;
 
 export const title = "${titulo}";
@@ -411,7 +498,7 @@ export async function load(_params: Record<string, string>, { url }: LoadContext
   const page = Math.max(1, Math.floor(Number(url.searchParams.get("page"))) || 1);
   // One more than a page, to know whether there is a next one.
   const rows = await ${camel(n.list)}(await db(), { limit: PAGE + 1, offset: (page - 1) * PAGE });
-  return { page, rows: rows.slice(0, PAGE), more: rows.length > PAGE };
+  return { page, rows: rows.slice(0, PAGE), more: rows.length > PAGE${conOpciones ? `, options: await ${opcionesFn}(await db())` : ""} };
 }
 
 /** How a value of any column reads in a cell. */
@@ -421,6 +508,12 @@ function show(value: unknown): string {
   if (typeof value === "boolean") return value ? "yes" : "no";
   return String(value);
 }
+${conOpciones ? `
+/** A key of another table, by its name. */
+function label(options: Option[], value: unknown): string {
+  return options.find((o) => o.value === String(value))?.label ?? show(value);
+}
+` : ""}
 
 export default function ${n.plural}({ data }: { data: Awaited<ReturnType<typeof load>> }) {
   return view\`
@@ -449,7 +542,7 @@ export default function ${n.plural}({ data }: { data: Awaited<ReturnType<typeof
   // Crear dentro de try: un UNIQUE repetido vuelve al formulario. La
   // redirección va fuera, porque también se lanza.
   const intento = (asignar, despues) =>
-    `${asignar ? `let ${asignar};\n    ` : ""}try {\n      ${asignar ? `${asignar} = ` : ""}await ${camel(n.create)}(await db(), ${datos});\n    } catch (error) {\n      return duplicate(error, formData);\n    }\n    throw redirect(\`${base}/\${${despues}}\`);`;
+    `${asignar ? `let ${asignar};\n    ` : ""}try {\n      ${asignar ? `${asignar} = ` : ""}await ${camel(n.create)}(await db(), ${datos});\n    } catch (error) {\n      return rejected(error, formData);\n    }\n    throw redirect(\`${base}/\${${despues}}\`);`;
   const despuesDeCrear = a.mysql
     ? a.claveAutomatica
       ? intento("id", "id")
@@ -461,10 +554,14 @@ import { fail, redirect, validate, type ActionContext, type FormResult } from "v
 
 import { ${camel(n.create)} } from "${db.nested}";
 import { db } from "${pool.nested}";
-import { ${nuevaForma}, ${campos}, ${params}, duplicate } from "${resource.nested}";
+import { ${nuevaForma}, ${campos}, ${params}, ${opcionesFn}, rejected } from "${resource.nested}";
 
 export const title = "New ${uno}";
 
+export async function load() {
+  return { options: await ${opcionesFn}(await db()) };
+}
+
 export const actions = {
   async default({ formData }: ActionContext) {
     const result = await validate(${nuevaForma}, formData);
@@ -473,13 +570,13 @@ export const actions = {
   },
 };
 
-export default function New${n.uno}({ form }: { form?: FormResult<typeof ${nuevaForma}> }) {
+export default function New${n.uno}({ data, form }: { data: Awaited<ReturnType<typeof load>>; form?: FormResult<typeof ${nuevaForma}> }) {
   const failed = form?.ok === false ? form : undefined;
   return view\`
     <section>
       <h1>New ${uno}</h1>
       <form method="post">
-        <${campos} values=\${failed?.values ?? {}} errors=\${failed?.errors ?? {}}${a.claveAutomatica ? "" : " withKey=\${true}"}/>
+        <${campos} values=\${failed?.values ?? {}} errors=\${failed?.errors ?? {}} options=\${data.options}${a.claveAutomatica ? "" : " withKey=\${true}"}/>
         <button>Create</button>
       </form>
       <p><a href="${base}">Back</a></p>
@@ -497,7 +594,7 @@ export default function New${n.uno}({ form }: { form?: FormResult<typeof ${nueva
     try {
       changed = await ${camel(n.update)}(await db(), { ...${params}(result.data), ${propiedad(pk)}: id });
     } catch (error) {
-      return duplicate(error, formData);
+      return rejected(error, formData);
     }
     if (changed === 0) throw notFound();
     throw redirect("${base}");
@@ -509,7 +606,7 @@ import { fail, notFound, redirect, validate, type ActionContext, type FormResult
 
 import { ${[camel(n.get), a.alEditar.length ? camel(n.update) : null, camel(n.delete)].filter(Boolean).join(", ")} } from "${db.nested}";
 import { db } from "${pool.nested}";
-import { ${forma}, ${campos}, ${params}, ${values}, duplicate } from "${resource.nested}";
+import { ${forma}, ${campos}, ${params}, ${values}, ${opcionesFn}, rejected } from "${resource.nested}";
 
 type Params = { id: string };
 
@@ -524,23 +621,29 @@ export const title = ({ id }: Params) => \`${etiqueta(singular(tabla.name))} \${
 export async function load({ id }: Params) {
   const row = await ${camel(n.get)}(await db(), { ${propiedad(pk)}: key(id) });
   if (!row) throw notFound();
-  return row;
+  return { row, options: await ${opcionesFn}(await db()) };
 }
 
 export const actions = {${actualizar}
-  async delete({ params }: ActionContext<Params>) {
-    await ${camel(n.delete)}(await db(), { ${propiedad(pk)}: key(params.id) });
+  async delete({ params, formData }: ActionContext<Params>) {
+    try {
+      await ${camel(n.delete)}(await db(), { ${propiedad(pk)}: key(params.id) });
+    } catch (error) {
+      return rejected(error, formData);
+    }
     throw redirect("${base}");
   },
 };
 
 export default function Edit${n.uno}({ data, form }: { data: Awaited<ReturnType<typeof load>>; form?: FormResult<typeof ${forma}> }) {
   const failed = form?.ok === false ? form : undefined;
+  // A rejected delete sends no fields: the form keeps showing the row.
+  const shown = failed && Object.keys(failed.values).length > 0 ? failed.values : ${values}(data.row);
   return view\`
     <section>
-      <h1>${etiqueta(singular(tabla.name))} \${String(${fila("data")})}</h1>
+      <h1>${etiqueta(singular(tabla.name))} \${String(${fila("data.row")})}</h1>
       ${a.alEditar.length ? `<form method="post">
-        <${campos} values=\${failed?.values ?? ${values}(data)} errors=\${failed?.errors ?? {}}/>
+        <${campos} values=\${shown} errors=\${failed?.errors ?? {}} options=\${data.options}/>
         <button>Save</button>
       </form>
       ` : ""}<form method="post" action="?/delete">
@@ -599,12 +702,19 @@ export function readGrid(formData: FormData, columns: readonly string[]): { rows
 }
 
 /** Una celda editable de la grilla, con su error debajo. */
-function celda(c, valoresEnum) {
+function celda(c, valoresEnum, relacion) {
   const nombre = `\${\`c\${r.index}.${c.name}\`}`;
   const v = `r.values${acceso(c.name)}`;
   const texto = `String(${v} ?? "")`;
   let html;
-  switch (c.kind) {
+  switch (relacion ? "relacion" : c.kind) {
+    case "relacion": {
+      const vacia = c.nullable ? `<option value=""></option>` : "";
+      html =
+        `<select name=${nombre}>${vacia}<For each=\${() => data.options${acceso(c.name)}} key=\${(o: Option) => o.value} ` +
+        `render=\${(o: Option) => view\`<option value=\${o.value} prop:selected=\${${v} === o.value}>\${o.label}</option>\`}/></select>`;
+      break;
+    }
     case "boolean":
       html = `<input type="checkbox" name=${nombre} prop:checked=\${${v} === "on"}>`;
       break;
@@ -653,7 +763,8 @@ export function rejilla(tabla, a, n, { db, pool, resource, grid, base, enums })
   const importsEnum = [...new Set(a.alEditar.filter((c) => c.kind === "enum" && enums.has(c.sqlType)).map((c) => `${camel(c.sqlType)}Values`))];
   const columnas = a.alEditar.map((c) => JSON.stringify(c.name)).join(", ");
   const cabeceras = [pk, ...a.alEditar.map((c) => c.name)].map((c) => `<th>${etiqueta(c)}</th>`).join("");
-  const celdas = a.alEditar.map((c) => celda(c, valoresEnumDe(c, enums))).join("\n               ");
+  const celdas = a.alEditar.map((c) => celda(c, valoresEnumDe(c, enums), relacionDe(a, c))).join("\n               ");
+  const opcionesFn = `${camel(n.uno)}Options`;
 
   return `// Generated by ascua-scaffold. Yours to edit: it is not generated again.
 //
@@ -665,7 +776,7 @@ import { fail, notFound, redirect, validate, type ActionContext, type LoadContex
 import { ${[...importsEnum, camel(n.list), "transaction", camel(n.update)].join(", ")} } from "${db}";
 import { db } from "${pool}";
 import { readGrid, type FormErrors, type FormValues } from "${grid}";
-import { ${forma}, ${params}, ${values}, duplicate, type ${n.uno}Data } from "${resource}";
+import { ${forma}, ${params}, ${values}, ${opcionesFn}, rejected, type ${n.uno}Data, type Option } from "${resource}";
 
 const PAGE = 50;
 const COLUMNS = [${columnas}] as const;
@@ -685,6 +796,7 @@ export async function load(_params: Record<string, string>, { url }: LoadContext
     page,
     more: rows.length > PAGE,
     rows: rows.slice(0, PAGE).map((row) => ({ key: String(row${acceso(pk)}), values: ${values}(row) })),
+    options: await ${opcionesFn}(await db()),
   };
 }
 
@@ -716,8 +828,8 @@ export const actions = {
         }
       });
     } catch (error) {
-      // A repeated UNIQUE value: the error goes under that row's cell.
-      const taken = duplicate(error, new FormData());
+      // A repeated UNIQUE value or a missing key: the error goes under that row's cell.
+      const taken = rejected(error, new FormData());
       return fail(409, { errors: { [current]: taken.data.errors }, values } satisfies Failed);
     }
     throw redirect(url.pathname + url.search);
@@ -765,6 +877,130 @@ export default function ${n.plural}Grid({ data, form }: { data: Awaited<ReturnTy
 `;
 }
 
+/** `src/resources/admin.ts`: las tablas del admin. Se reescribe en cada `--admin`. */
+export function datosAdmin(incluidas, saltadas) {
+  const filas = incluidas.map((x) => `  { name: ${JSON.stringify(x.name)}, label: ${JSON.stringify(etiqueta(x.name))}, path: ${JSON.stringify(x.path)} },`).join("\n");
+  // Los motivos vienen de la CLI, con \`nombres\` entre comillas invertidas: en la página, sin ellas.
+  const fuera = saltadas.map((x) => `  { name: ${JSON.stringify(x.name)}, reason: ${JSON.stringify(x.reason.replace(/\`/g, ""))} },`).join("\n");
+  return `// Written by \`ascua-scaffold --admin\` each time it runs: edits here are lost.
+
+/** The tables the admin manages, in the order of the migrations. */
+export const adminTables: readonly { name: string; label: string; path: string }[] = [
+${filas}
+];
+
+/** The tables it left out, and why. */
+export const skippedTables: readonly { name: string; reason: string }[] = [
+${fuera}
+];
+`;
+}
+
+/** `src/routes/admin/_middleware.ts`: sin contraseña configurada, el admin no existe. */
+export function guardiaAdmin() {
+  return `// Generated by ascua-scaffold. Yours to edit: it is not generated again.
+import { notFound, type Middleware } from "vite-plugin-ascua/site";
+
+/**
+ * The admin asks for a user and a password (HTTP Basic): ADMIN_USER, "admin"
+ * by default, and ADMIN_PASSWORD. Without ADMIN_PASSWORD the admin does not
+ * exist: every page under /admin is a 404. Serve it over HTTPS only, and swap
+ * this for the site's own sign-in (passkeys, a session) when it has one.
+ */
+const middleware: Middleware = ({ request, setHeaders }) => {
+  setHeaders({ "cache-control": "no-store", "x-robots-tag": "noindex" });
+  const password = process.env.ADMIN_PASSWORD;
+  if (!password) throw notFound();
+  const expected = \`Basic \${base64(\`\${process.env.ADMIN_USER || "admin"}:\${password}\`)}\`;
+  if (!same(request.headers.get("authorization") ?? "", expected)) {
+    return new Response("Sign in to the admin.", {
+      status: 401,
+      headers: { "www-authenticate": 'Basic realm="admin", charset="UTF-8"', "cache-control": "no-store" },
+    });
+  }
+};
+
+export default middleware;
+
+/** UTF-8 to base64, the same on Node and on Workers. */
+function base64(text: string): string {
+  return btoa(String.fromCharCode(...new TextEncoder().encode(text)));
+}
+
+/** Compares without stopping at the first difference: the time it takes does not tell how much matched. */
+function same(a: string, b: string): boolean {
+  let diff = a.length ^ b.length;
+  for (let i = 0; i < Math.max(a.length, b.length); i++) diff |= (a.charCodeAt(i) || 0) ^ (b.charCodeAt(i) || 0);
+  return diff === 0;
+}
+`;
+}
+
+/** `src/routes/admin/_layout.ts`: la barra con las tablas. */
+export function marcoAdmin(datos) {
+  return `// Generated by ascua-scaffold. Yours to edit: it is not generated again.
+import type { LayoutProps } from "vite-plugin-ascua/site";
+
+import { adminTables } from "${datos}";
+
+type AdminTable = (typeof adminTables)[number];
+
+/** Every admin page: the tables on the side, the page on the right. */
+export default function AdminLayout(props: LayoutProps) {
+  const frame = view\`
+    <div class="admin">
+      <nav>
+        <a href="/admin"><strong>Admin</strong></a>
+        <For each=\${() => adminTables} key=\${(t: AdminTable) => t.name}
+             render=\${(t: AdminTable) => view\`<a href=\${t.path} class:current=\${props.path.startsWith(t.path)}>\${t.label}</a>\`}/>
+      </nav>
+      <div class="page"></div>
+      <style>
+        .admin { display: grid; grid-template-columns: 12rem 1fr; gap: 1.5rem; }
+        .admin nav { display: grid; align-content: start; gap: .25rem; }
+        .admin nav .current { font-weight: bold; }
+        @media (max-width: 40rem) { .admin { grid-template-columns: 1fr; } }
+      </style>
+    </div>\`;
+  props.children(frame.querySelector(".page")!);
+  return frame;
+}
+`;
+}
+
+/** `src/routes/admin/index.ts`: el panel. */
+export function panelAdmin(datos) {
+  return `// Generated by ascua-scaffold. Yours to edit: it is not generated again.
+import { adminTables, skippedTables } from "${datos}";
+
+export const title = "Admin";
+
+type AdminTable = (typeof adminTables)[number];
+type Skipped = (typeof skippedTables)[number];
+
+export default function Admin() {
+  return view\`
+    <section>
+      <h1>Admin</h1>
+      <table>
+        <thead><tr><th>Table</th><th></th></tr></thead>
+        <tbody>
+          <For each=\${() => adminTables} key=\${(t: AdminTable) => t.name}
+               render=\${(t: AdminTable) => view\`<tr><td><a href=\${t.path}>\${t.label}</a></td><td><a href=\${\`\${t.path}/new\`}>New</a> · <a href=\${\`\${t.path}/grid\`}>Grid</a></td></tr>\`}/>
+        </tbody>
+      </table>
+      <Show when=\${() => skippedTables.length > 0}>
+        <h2>Left out</h2>
+        <ul>
+          <For each=\${() => skippedTables} key=\${(t: Skipped) => t.name}
+               render=\${(t: Skipped) => view\`<li><code>\${t.name}</code>: \${t.reason}</li>\`}/>
+        </ul>
+      </Show>
+    </section>\`;
+}
+`;
+}
+
 /** `src/pool.ts`: un pool para todo el servidor, con las migraciones aplicadas una vez. */
 export function piscina({ mysql, migrate, db }) {
   if (mysql) {

package/index.js

@@ -16,10 +16,11 @@ import { createRequire } from "node:module";
 import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
-import { analizar, ayudaRejilla, consultasSql, nombres, piscina, recurso, rejilla, rutas, ScaffoldError, t } from "./generate.js";
+import { analizar, ayudaRejilla, camel, consultaOpciones, consultasSql, datosAdmin, guardiaAdmin, marcoAdmin, nombres, panelAdmin, piscina, recurso, rejilla, rutas, ScaffoldError, t } from "./generate.js";
 
 const AYUDA = t(
   `Uso: ascua-scaffold <tabla> [opciones]
+     ascua-scaffold --admin [opciones]
 
 Genera, a partir de una tabla de las migraciones de brasa:
   db/queries/<tabla>.sql          List, Get, Create, Update y Delete
@@ -33,9 +34,11 @@ Genera, a partir de una tabla de las migraciones de brasa:
 
 Opciones:
   --config <ruta>   el brasa.json (por defecto, el del directorio actual)
+  --admin           todas las tablas bajo /admin, con su panel; pide ADMIN_PASSWORD
   --force           reescribe los archivos que ya existan
   -h, --help        esta ayuda`,
   `Usage: ascua-scaffold <table> [options]
+       ascua-scaffold --admin [options]
 
 Generates, from a table in the brasa migrations:
   db/queries/<table>.sql          List, Get, Create, Update and Delete
@@ -49,6 +52,7 @@ Generates, from a table in the brasa migrations:
 
 Options:
   --config <path>   the brasa.json (default: the one in the current directory)
+  --admin           every table under /admin, with a dashboard; asks for ADMIN_PASSWORD
   --force           overwrite files that already exist
   -h, --help        this help`,
 );
@@ -57,11 +61,12 @@ const POR_DEFECTO = { dialect: "postgres", migrations: "db/migrations", queries:
 
 /** `["posts", "--force"]` → `{ table: "posts", force: true }`. */
 export function leerArgumentos(argv) {
-  const salida = { table: undefined, config: "brasa.json", force: false, ayuda: false };
+  const salida = { table: undefined, config: "brasa.json", force: false, admin: false, ayuda: false };
   for (let i = 0; i < argv.length; i++) {
     const a = argv[i];
     if (a === "-h" || a === "--help") salida.ayuda = true;
     else if (a === "--force") salida.force = true;
+    else if (a === "--admin") salida.admin = true;
     else if (a === "--config") salida.config = argv[++i];
     else if (a.startsWith("--config=")) salida.config = a.slice("--config=".length);
     else if (!a.startsWith("-") && salida.table === undefined) salida.table = a;
@@ -99,140 +104,234 @@ function importar(desde, hacia) {
   return r;
 }
 
-export async function main(argv = process.argv.slice(2)) {
-  const args = leerArgumentos(argv);
-  if (args.ayuda || !args.table) {
-    console.log(AYUDA);
-    return args.ayuda ? 0 : 1;
-  }
-
+/** brasa.json, el esquema y el brasa del proyecto. */
+async function proyecto(args) {
   const rutaConfig = resolve(args.config);
   const raiz = dirname(rutaConfig);
   if (!existsSync(rutaConfig)) {
     throw new ScaffoldError(t(`no existe ${rutaConfig}: crea uno con \`brasa init\``, `${rutaConfig} does not exist: create one with \`brasa init\``));
   }
   const config = { ...POR_DEFECTO, ...JSON.parse(readFileSync(rutaConfig, "utf8")) };
-  const mysql = config.dialect === "mysql";
-  const dirMigraciones = resolve(raiz, config.migrations);
-  const dirConsultas = resolve(raiz, config.queries);
-  const out = resolve(raiz, config.out);
-
   const brasa = await cargarBrasa(raiz);
-  const migrations = leerSql(dirMigraciones);
-  const queries = leerSql(dirConsultas);
-  const salida = brasa.compile({ dialect: config.dialect, migrate: config.migrate, migrations, queries });
+  const dirConsultas = resolve(raiz, config.queries);
+  const salida = brasa.compile({
+    dialect: config.dialect,
+    migrate: config.migrate,
+    migrations: leerSql(resolve(raiz, config.migrations)),
+    queries: leerSql(dirConsultas),
+  });
   if (salida.code === null) {
     throw new ScaffoldError(t("el esquema o las consultas tienen errores: corre `brasa generate` para verlos", "the schema or the queries have errors: run `brasa generate` to see them"));
   }
   if (!salida.tables) {
     throw new ScaffoldError(t("este brasa-sql no describe las tablas: actualízalo", "this brasa-sql does not describe tables: update it"));
   }
+  return {
+    rutaConfig,
+    raiz,
+    config,
+    brasa,
+    salida,
+    dirConsultas,
+    mysql: config.dialect === "mysql",
+    out: resolve(raiz, config.out),
+    pool: join(raiz, "src", "pool.ts"),
+    ayuda: join(raiz, "src", "resources", "grid.ts"),
+  };
+}
 
-  const tabla = salida.tables.find((x) => x.name === args.table) ?? salida.tables.find((x) => x.name.toLowerCase() === args.table.toLowerCase());
-  if (!tabla) {
-    const hay = salida.tables.filter((x) => !x.view).map((x) => x.name);
-    throw new ScaffoldError(
-      t(`no hay una tabla \`${args.table}\` en las migraciones. Hay: ${hay.join(", ") || "ninguna"}`, `there is no \`${args.table}\` table in the migrations. There are: ${hay.join(", ") || "none"}`),
-    );
-  }
-
-  const a = analizar(tabla, { mysql });
+/**
+ * Los archivos de una tabla y lo que llevan. Lanza `ScaffoldError` si no se
+ * puede generar. Con `reutilizar`, una tabla que ya tiene sus cinco consultas
+ * y su `resources/<tabla>.ts` los conserva y solo recibe rutas nuevas.
+ */
+function planTabla(p, tabla, { prefijo, force, reutilizar }) {
+  const a = analizar(tabla, { mysql: p.mysql, tablas: p.salida.tables });
   const n = nombres(tabla);
-  // Con --force, las del archivo que se va a reescribir no cuentan.
-  const propio = join(dirConsultas, `${tabla.name}.sql`);
-  const ajenas = salida.queries.filter((x) => !(args.force && resolve(x.file) === propio));
-  const repetidas = [n.list, n.get, n.create, n.update, n.delete].filter((q) => ajenas.some((x) => x.name === q));
-  const enPropio = repetidas.filter((q) => salida.queries.some((x) => x.name === q && resolve(x.file) === propio));
-  if (repetidas.length && enPropio.length === repetidas.length) {
-    // Las del ejemplo de `brasa init`, por ejemplo: están en el archivo que se va a escribir.
-    const archivo = relative(process.cwd(), propio);
-    throw new ScaffoldError(
-      t(`${archivo} ya tiene ${repetidas.join(", ")}. Con --force se reemplaza ese archivo`, `${archivo} already has ${repetidas.join(", ")}. Use --force to replace that file`),
-    );
-  }
-  if (repetidas.length) {
-    throw new ScaffoldError(
-      t(`ya hay consultas con estos nombres: ${repetidas.join(", ")}. Quita esas o genera otra tabla`, `queries with these names already exist: ${repetidas.join(", ")}. Remove them or scaffold another table`),
-    );
-  }
-
   const carpeta = tabla.name.replace(/_/g, "-").toLowerCase();
   if (carpeta === "grid") {
     throw new ScaffoldError(t("una tabla `grid` chocaría con src/resources/grid.ts, que comparten las grillas", "a `grid` table would clash with src/resources/grid.ts, which the grids share"));
   }
   // Los enums de Postgres tienen su `<x>Values` en el módulo; los de MySQL
   // (`ENUM('a','b')` en la columna), no: sus valores van escritos.
-  const enums = new Set(mysql ? [] : tabla.columns.filter((c) => c.kind === "enum").map((c) => c.sqlType));
+  const enums = new Set(p.mysql ? [] : tabla.columns.filter((c) => c.kind === "enum").map((c) => c.sqlType));
 
-  const archivos = {
-    sql: join(dirConsultas, `${tabla.name}.sql`),
-    recurso: join(raiz, "src", "resources", `${carpeta}.ts`),
-    index: join(raiz, "src", "routes", carpeta, "index.ts"),
-    nuevo: join(raiz, "src", "routes", carpeta, "new.ts"),
-    editar: join(raiz, "src", "routes", carpeta, "[id].ts"),
-    rejilla: join(raiz, "src", "routes", carpeta, "grid.ts"),
-    pool: join(raiz, "src", "pool.ts"),
-    ayuda: join(raiz, "src", "resources", "grid.ts"),
-  };
-  const existentes = Object.entries(archivos).filter(([k, f]) => k !== "pool" && k !== "ayuda" && existsSync(f));
-  if (existentes.length && !args.force) {
+  const sql = join(p.dirConsultas, `${tabla.name}.sql`);
+  const archivoRecurso = join(p.raiz, "src", "resources", `${carpeta}.ts`);
+  const consultas = [n.list, n.get, n.create, n.update, n.delete, ...a.relaciones.map((r) => consultaOpciones(n, r))];
+  const hay = consultas.filter((q) => p.salida.queries.some((x) => x.name === q));
+  // Un recurso de un ascua-scaffold anterior a las relaciones no trae `<x>Options`.
+  const conOpciones = existsSync(archivoRecurso) && readFileSync(archivoRecurso, "utf8").includes(`function ${camel(n.uno)}Options(`);
+  const reusa = reutilizar && !force && hay.length === consultas.length && conOpciones;
+  if (reutilizar && !force && hay.length === consultas.length && existsSync(archivoRecurso) && !conOpciones) {
     throw new ScaffoldError(
-      t(`ya existen: ${existentes.map(([, f]) => relative(raiz, f)).join(", ")}. Usa --force para reescribirlos`, `already exist: ${existentes.map(([, f]) => relative(raiz, f)).join(", ")}. Use --force to overwrite them`),
+      t(`${relative(p.raiz, archivoRecurso)} es de un ascua-scaffold anterior: regenéralo con \`ascua-scaffold ${tabla.name} --force\``, `${relative(p.raiz, archivoRecurso)} is from an older ascua-scaffold: regenerate it with \`ascua-scaffold ${tabla.name} --force\``),
     );
   }
 
+  if (!reusa) {
+    // Con --force, las del archivo que se va a reescribir no cuentan.
+    const ajenas = p.salida.queries.filter((x) => !(force && resolve(x.file) === sql));
+    const repetidas = consultas.filter((q) => ajenas.some((x) => x.name === q));
+    const enPropio = repetidas.filter((q) => p.salida.queries.some((x) => x.name === q && resolve(x.file) === sql));
+    if (repetidas.length && enPropio.length === repetidas.length) {
+      // Las del ejemplo de `brasa init`, por ejemplo: están en el archivo que se va a escribir.
+      const archivo = relative(process.cwd(), sql);
+      throw new ScaffoldError(t(`${archivo} ya tiene ${repetidas.join(", ")}. Con --force se reemplaza ese archivo`, `${archivo} already has ${repetidas.join(", ")}. Use --force to replace that file`));
+    }
+    if (repetidas.length) {
+      throw new ScaffoldError(t(`ya hay consultas con estos nombres: ${repetidas.join(", ")}. Quita esas o genera otra tabla`, `queries with these names already exist: ${repetidas.join(", ")}. Remove them or scaffold another table`));
+    }
+  }
+
+  const dirRutas = join(p.raiz, "src", "routes", ...(prefijo ? [prefijo] : []), carpeta);
+  const base = `${prefijo ? `/${prefijo}` : ""}/${carpeta}`;
+  const archivos = {
+    sql,
+    recurso: archivoRecurso,
+    index: join(dirRutas, "index.ts"),
+    nuevo: join(dirRutas, "new.ts"),
+    editar: join(dirRutas, "[id].ts"),
+    rejilla: join(dirRutas, "grid.ts"),
+  };
+  if (reusa) {
+    delete archivos.sql;
+    delete archivos.recurso;
+  }
+  const existentes = Object.values(archivos).filter((f) => existsSync(f));
+  if (existentes.length && !force) {
+    const lista = existentes.map((f) => relative(p.raiz, f)).join(", ");
+    throw new ScaffoldError(t(`ya existen: ${lista}. Usa --force para reescribirlos`, `already exist: ${lista}. Use --force to overwrite them`));
+  }
+
   const r = rutas(tabla, a, n, {
-    db: { index: importar(archivos.index, out), nested: importar(archivos.nuevo, out) },
-    pool: { index: importar(archivos.index, archivos.pool), nested: importar(archivos.nuevo, archivos.pool) },
-    resource: { nested: importar(archivos.nuevo, archivos.recurso) },
-    base: `/${carpeta}`,
+    db: { index: importar(archivos.index, p.out), nested: importar(archivos.nuevo, p.out) },
+    pool: { index: importar(archivos.index, p.pool), nested: importar(archivos.nuevo, p.pool) },
+    resource: { nested: importar(archivos.nuevo, archivoRecurso) },
+    base,
   });
   const contenidos = {
-    sql: consultasSql(tabla, a, n),
-    recurso: recurso(tabla, a, n, { db: importar(archivos.recurso, out), enums }),
     index: r.index,
     nuevo: r.nuevo,
     editar: r.editar,
     rejilla: rejilla(tabla, a, n, {
-      db: importar(archivos.rejilla, out),
-      pool: importar(archivos.rejilla, archivos.pool),
-      resource: importar(archivos.rejilla, archivos.recurso),
-      grid: importar(archivos.rejilla, archivos.ayuda),
-      base: `/${carpeta}`,
+      db: importar(archivos.rejilla, p.out),
+      pool: importar(archivos.rejilla, p.pool),
+      resource: importar(archivos.rejilla, archivoRecurso),
+      grid: importar(archivos.rejilla, p.ayuda),
+      base,
       enums,
     }),
   };
-  const escritos = [];
-  for (const [k, contenido] of Object.entries(contenidos)) {
-    mkdirSync(dirname(archivos[k]), { recursive: true });
-    writeFileSync(archivos[k], contenido);
-    escritos.push(archivos[k]);
-  }
-  if (!existsSync(archivos.ayuda)) {
-    writeFileSync(archivos.ayuda, ayudaRejilla());
-    escritos.push(archivos.ayuda);
+  if (!reusa) {
+    contenidos.sql = consultasSql(tabla, a, n);
+    contenidos.recurso = recurso(tabla, a, n, { db: importar(archivoRecurso, p.out), enums });
   }
-  if (!existsSync(archivos.pool)) {
-    writeFileSync(archivos.pool, piscina({ mysql, migrate: config.migrate, db: importar(archivos.pool, out) }));
-    escritos.push(archivos.pool);
+  return { tabla: tabla.name, base, archivos, contenidos, reusa };
+}
+
+/** Escribe los planes y lo común (el pool, el ayudante de la grilla); devuelve lo escrito. */
+function escribir(p, planes, extra = {}) {
+  const escritos = [];
+  const poner = (archivo, contenido) => {
+    mkdirSync(dirname(archivo), { recursive: true });
+    writeFileSync(archivo, contenido);
+    escritos.push(archivo);
+  };
+  for (const plan of planes) {
+    for (const [k, contenido] of Object.entries(plan.contenidos)) poner(plan.archivos[k], contenido);
   }
+  for (const [archivo, contenido] of Object.entries(extra)) poner(archivo, contenido);
+  if (!existsSync(p.ayuda)) poner(p.ayuda, ayudaRejilla());
+  if (!existsSync(p.pool)) poner(p.pool, piscina({ mysql: p.mysql, migrate: p.config.migrate, db: importar(p.pool, p.out) }));
+  return escritos;
+}
 
-  // El módulo de brasa, con las consultas nuevas.
-  const generado = spawnSync(process.execPath, [brasa.bin, "generate", "--config", rutaConfig], { cwd: raiz, stdio: "inherit" });
+/** El módulo de brasa con las consultas nuevas, y lo que falta en el proyecto. */
+function terminar(p, escritos, listo) {
+  const generado = spawnSync(process.execPath, [p.brasa.bin, "generate", "--config", p.rutaConfig], { cwd: p.raiz, stdio: "inherit" });
   if (generado.status !== 0) {
     throw new ScaffoldError(t("brasa no pudo generar el módulo con las consultas nuevas (arriba, el error)", "brasa could not generate the module with the new queries (the error is above)"));
   }
-
   for (const f of escritos) console.log(`  ${relative(process.cwd(), f)}`);
-  const paquete = existsSync(join(raiz, "package.json")) ? JSON.parse(readFileSync(join(raiz, "package.json"), "utf8")) : {};
+  const paquete = existsSync(join(p.raiz, "package.json")) ? JSON.parse(readFileSync(join(p.raiz, "package.json"), "utf8")) : {};
   const deps = { ...paquete.dependencies, ...paquete.devDependencies };
-  const faltan = (mysql ? ["mysql2"] : ["pg", "@types/pg"]).concat("@types/node").filter((d) => !deps[d]);
+  const faltan = (p.mysql ? ["mysql2"] : ["pg", "@types/pg"]).concat("@types/node").filter((d) => !deps[d]);
   console.log("");
-  console.log(t(`Listo: /${carpeta} en el sitio.`, `Done: /${carpeta} on the site.`));
+  console.log(listo);
   if (faltan.length) console.log(t(`Falta instalar: stil add ${faltan.join(" ")}`, `Still to install: npm i ${faltan.join(" ")}`));
-  if (!/mode:\s*["']server["']/.test(leer(join(raiz, "vite.config.ts")))) {
+  if (!/mode:\s*["']server["']/.test(leer(join(p.raiz, "vite.config.ts")))) {
     console.log(t('Las acciones necesitan servidor: ascua({ site: { mode: "server" } }) en vite.config.ts', 'Actions need a server: ascua({ site: { mode: "server" } }) in vite.config.ts'));
   }
+}
+
+/** `--admin`: todas las tablas bajo /admin, con su panel y su contraseña. */
+function admin(p, args) {
+  const planes = [];
+  const saltadas = [];
+  const conservadas = [];
+  for (const tabla of p.salida.tables) {
+    // Una tabla que ya tiene su página en el admin se queda como está.
+    const carpeta = tabla.name.replace(/_/g, "-").toLowerCase();
+    if (!args.force && existsSync(join(p.raiz, "src", "routes", "admin", carpeta, "index.ts"))) {
+      conservadas.push({ name: tabla.name, path: `/admin/${carpeta}` });
+      continue;
+    }
+    try {
+      planes.push(planTabla(p, tabla, { prefijo: "admin", force: args.force, reutilizar: true }));
+    } catch (error) {
+      if (!(error instanceof ScaffoldError)) throw error;
+      saltadas.push({ name: tabla.name, reason: error.message });
+    }
+  }
+  if (planes.length === 0 && conservadas.length === 0) {
+    const motivos = saltadas.map((x) => `\n  ${x.name}: ${x.reason}`).join("");
+    throw new ScaffoldError(t(`ninguna tabla se pudo generar:${motivos}`, `no table could be scaffolded:${motivos}`));
+  }
+
+  const dir = join(p.raiz, "src", "routes", "admin");
+  const datos = join(p.raiz, "src", "resources", "admin.ts");
+  // En el orden de las migraciones, las de antes y las nuevas.
+  const orden = p.salida.tables.map((x) => x.name);
+  const incluidas = [...conservadas, ...planes.map((x) => ({ name: x.tabla, path: x.base }))].sort((a, b) => orden.indexOf(a.name) - orden.indexOf(b.name));
+  const extra = { [datos]: datosAdmin(incluidas, saltadas) };
+  const propios = {
+    [join(dir, "_middleware.ts")]: guardiaAdmin(),
+    [join(dir, "_layout.ts")]: marcoAdmin(importar(join(dir, "_layout.ts"), datos)),
+    [join(dir, "index.ts")]: panelAdmin(importar(join(dir, "index.ts"), datos)),
+  };
+  // El panel, la barra y la contraseña son tuyos: se escriben si faltan.
+  for (const [archivo, contenido] of Object.entries(propios)) {
+    if (args.force || !existsSync(archivo)) extra[archivo] = contenido;
+  }
+
+  const escritos = escribir(p, planes, extra);
+  const cuantas = incluidas.length === 1 ? t("1 tabla", "1 table") : t(`${incluidas.length} tablas`, `${incluidas.length} tables`);
+  terminar(p, escritos, t(`Listo: /admin con ${cuantas} (${planes.length} nuevas).`, `Done: /admin with ${cuantas} (${planes.length} new).`));
+  for (const plan of planes.filter((x) => x.reusa)) {
+    console.log(t(`  ${plan.tabla}: usa las consultas y el formulario que ya tenía`, `  ${plan.tabla}: uses the queries and form it already had`));
+  }
+  for (const x of saltadas) console.log(t(`  fuera: ${x.name}: ${x.reason}`, `  left out: ${x.name}: ${x.reason}`));
+  console.log(t("Pide usuario y contraseña: define ADMIN_PASSWORD (y ADMIN_USER, «admin» por defecto). Sin ella, /admin es un 404.", "It asks for a user and password: set ADMIN_PASSWORD (and ADMIN_USER, \"admin\" by default). Without it, /admin is a 404."));
+  return 0;
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const args = leerArgumentos(argv);
+  if (args.ayuda || (!args.table && !args.admin)) {
+    console.log(AYUDA);
+    return args.ayuda ? 0 : 1;
+  }
+  const p = await proyecto(args);
+  if (args.admin) return admin(p, args);
+
+  const tabla = p.salida.tables.find((x) => x.name === args.table) ?? p.salida.tables.find((x) => x.name.toLowerCase() === args.table.toLowerCase());
+  if (!tabla) {
+    const hay = p.salida.tables.filter((x) => !x.view).map((x) => x.name);
+    throw new ScaffoldError(t(`no hay una tabla \`${args.table}\` en las migraciones. Hay: ${hay.join(", ") || "ninguna"}`, `there is no \`${args.table}\` table in the migrations. There are: ${hay.join(", ") || "none"}`));
+  }
+  const plan = planTabla(p, tabla, { prefijo: "", force: args.force, reutilizar: false });
+  terminar(p, escribir(p, [plan]), t(`Listo: ${plan.base} en el sitio.`, `Done: ${plan.base} on the site.`));
   return 0;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ascua-scaffold",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "De una tabla de brasa a un recurso de Ascua: consultas, formulario validado y rutas para listar, crear, editar y borrar.",
   "keywords": ["ascua", "scaffold", "crud", "brasa", "sql", "forms"],
   "homepage": "https://ascua.gitweave.run",