ascua-scaffold 0.3.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,8 +88,8 @@ 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
 
@@ -112,7 +120,8 @@ con las tablas.
 
 - 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.

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);

package/index.js

@@ -16,7 +16,7 @@ import { createRequire } from "node:module";
 import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
-import { analizar, ayudaRejilla, consultasSql, datosAdmin, guardiaAdmin, marcoAdmin, nombres, panelAdmin, 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]
@@ -146,7 +146,7 @@ async function proyecto(args) {
  * 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 });
+  const a = analizar(tabla, { mysql: p.mysql, tablas: p.salida.tables });
   const n = nombres(tabla);
   const carpeta = tabla.name.replace(/_/g, "-").toLowerCase();
   if (carpeta === "grid") {
@@ -158,9 +158,16 @@ function planTabla(p, tabla, { prefijo, force, reutilizar }) {
 
   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];
+  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));
-  const reusa = reutilizar && !force && hay.length === consultas.length && existsSync(archivoRecurso);
+  // 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(`${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.
@@ -299,7 +306,8 @@ function admin(p, args) {
   }
 
   const escritos = escribir(p, planes, extra);
-  terminar(p, escritos, t(`Listo: /admin con ${incluidas.length} tablas (${planes.length} nuevas).`, `Done: /admin with ${incluidas.length} tables (${planes.length} new).`));
+  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`));
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ascua-scaffold",
-  "version": "0.3.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",