ascua-scaffold 0.1.1 → 0.3.0

package/README.md

@@ -37,6 +37,8 @@ src/resources/products.ts       el esquema del formulario, sus campos y las conv
 src/routes/products/index.ts    /products, de 50 en 50
 src/routes/products/new.ts      /products/new
 src/routes/products/[id].ts     /products/:id, editar y borrar (?/delete)
+src/routes/products/grid.ts     /products/grid, todas las filas editables a la vez
+src/resources/grid.ts           leer lo que manda una grilla (uno para todo el sitio)
 src/pool.ts                     el pool, con las migraciones aplicadas una vez (si no existe)
 ```
 
@@ -66,6 +68,46 @@ obligatoria y no tiene `DEFAULT`, el comando lo dice y no genera nada.
 Lo generado es tuyo: no se vuelve a generar. Con `--force` se reescribe
 encima.
 
+## La grilla
+
+`/products/grid` es la página entera editable, como una DataWindow de
+PowerBuilder: una fila por registro y una celda por campo, de 50 en 50. Es
+un `<form>` de HTML, así que también funciona sin JavaScript.
+
+- Cada fila lleva los valores con que se mostró: al guardar, solo se
+  escriben las filas que cambiaron.
+- Cada fila cambiada se valida con el mismo esquema del formulario
+  (`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.
+
+## 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
@@ -80,6 +122,7 @@ encima.
 
 ```text
 ascua-scaffold <tabla> [--config brasa.json] [--force]
+ascua-scaffold --admin [--config brasa.json] [--force]
 ```
 
 ## Licencia

package/generate.js

@@ -426,7 +426,7 @@ export default function ${n.plural}({ data }: { data: Awaited<ReturnType<typeof
   return view\`
     <section>
       <h1>${titulo}</h1>
-      <p><a href="${base}/new">New ${uno}</a></p>
+      <p><a href="${base}/new">New ${uno}</a> · <a href="${base}/grid">Edit as a grid</a></p>
       <table>
         <thead><tr>${cabeceras}</tr></thead>
         <tbody>
@@ -554,6 +554,341 @@ export default function Edit${n.uno}({ data, form }: { data: Awaited<ReturnType<
   return { index, nuevo, editar };
 }
 
+/** `src/resources/grid.ts`: leer lo que manda una grilla. Uno para todo el sitio. */
+export function ayudaRejilla() {
+  return `// Generated by ascua-scaffold. Yours to edit: it is not generated again.
+//
+// A grid is a plain <form>: one row per record, one field per cell. Each row
+// carries its key (k0, k1…) and the values it was shown with (w0, w1…), so
+// the server only writes the rows that changed. Cell names are c<row>.<column>.
+
+export type FormValues = Partial<Record<string, string | string[]>>;
+export type FormErrors = Partial<Record<string, string>>;
+
+/** A row of the grid: its key, as text, and the values of its fields. */
+export interface GridRow {
+  key: string;
+  values: FormValues;
+}
+
+/** Every row the grid sent, and the ones that changed. */
+export function readGrid(formData: FormData, columns: readonly string[]): { rows: GridRow[]; changed: GridRow[] } {
+  const rows: GridRow[] = [];
+  const changed: GridRow[] = [];
+  for (let i = 0; formData.has(\`k\${i}\`); i++) {
+    const key = String(formData.get(\`k\${i}\`));
+    const values: FormValues = {};
+    // An unchecked checkbox sends nothing, and stays missing: field.checkbox()
+    // takes any value that arrived, even "", as checked.
+    for (const column of columns) {
+      const value = formData.get(\`c\${i}.\${column}\`);
+      if (typeof value === "string") values[column] = value;
+    }
+    let was: FormValues = {};
+    try {
+      was = JSON.parse(String(formData.get(\`w\${i}\`) ?? "{}"));
+    } catch {
+      // Without what it was shown with, the row counts as changed.
+    }
+    rows.push({ key, values });
+    if (columns.some((column) => (was[column] ?? "") !== (values[column] ?? ""))) changed.push({ key, values });
+  }
+  return { rows, changed };
+}
+`;
+}
+
+/** Una celda editable de la grilla, con su error debajo. */
+function celda(c, valoresEnum) {
+  const nombre = `\${\`c\${r.index}.${c.name}\`}`;
+  const v = `r.values${acceso(c.name)}`;
+  const texto = `String(${v} ?? "")`;
+  let html;
+  switch (c.kind) {
+    case "boolean":
+      html = `<input type="checkbox" name=${nombre} prop:checked=\${${v} === "on"}>`;
+      break;
+    case "enum": {
+      const vacia = c.nullable ? `<option value=""></option>` : "";
+      html =
+        `<select name=${nombre}>${vacia}<For each=\${() => ${valoresEnum}} key=\${(v: string) => v} ` +
+        `render=\${(v: string) => view\`<option prop:selected=\${${v} === v}>\${v}</option>\`}/></select>`;
+      break;
+    }
+    case "integer":
+      html = `<input type="number" step="1" name=${nombre} prop:value=\${${texto}}>`;
+      break;
+    case "decimal":
+    case "number":
+      html = `<input type="number" step="any" name=${nombre} prop:value=\${${texto}}>`;
+      break;
+    case "date":
+      html = `<input type="date" name=${nombre} prop:value=\${${texto}}>`;
+      break;
+    case "datetime":
+      html = `<input type="datetime-local" name=${nombre} prop:value=\${${texto}}>`;
+      break;
+    case "time":
+      html = `<input type="time" name=${nombre} prop:value=\${${texto}}>`;
+      break;
+    default:
+      html = `<input name=${nombre} prop:value=\${${texto}}>`;
+  }
+  return `<td>${html}<small class="error">\${r.errors${acceso(c.name)} ?? ""}</small></td>`;
+}
+
+/** Los valores de un enum en el código generado: `<x>Values` o escritos. */
+export function valoresEnumDe(c, enums) {
+  return c.values ? (enums.has(c.sqlType) ? `${camel(c.sqlType)}Values` : JSON.stringify(c.values)) : "[]";
+}
+
+/** `src/routes/<tabla>/grid.ts`: la página entera editable, como una DataWindow. */
+export function rejilla(tabla, a, n, { db, pool, resource, grid, base, enums }) {
+  const { guarda, valor } = claveDeUrl(a);
+  const pk = a.clave.name;
+  const titulo = etiqueta(tabla.name);
+  const forma = `${n.uno}Form`;
+  const params = `${camel(n.uno)}Params`;
+  const values = `${camel(n.uno)}Values`;
+  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               ");
+
+  return `// Generated by ascua-scaffold. Yours to edit: it is not generated again.
+//
+// Every ${singular(tabla.name)} of the page, editable at once. Saving validates each changed
+// row with ${forma} and writes them all in one transaction: if one fails,
+// none is written, and the error shows in its cell.
+import { fail, notFound, redirect, validate, type ActionContext, type LoadContext } from "vite-plugin-ascua/site";
+
+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}";
+
+const PAGE = 50;
+const COLUMNS = [${columnas}] as const;
+
+export const title = "${titulo}";
+
+/** The key from the form, or a 404 if it cannot be one. */
+function key(id: string) {
+  if (!(${guarda})) throw notFound();
+  return ${valor};
+}
+
+export async function load(_params: Record<string, string>, { url }: LoadContext) {
+  const page = Math.max(1, Math.floor(Number(url.searchParams.get("page"))) || 1);
+  const rows = await ${camel(n.list)}(await db(), { limit: PAGE + 1, offset: (page - 1) * PAGE });
+  return {
+    page,
+    more: rows.length > PAGE,
+    rows: rows.slice(0, PAGE).map((row) => ({ key: String(row${acceso(pk)}), values: ${values}(row) })),
+  };
+}
+
+/** What a failed save sends back: the errors and what was written, by row key. */
+interface Failed {
+  errors: Record<string, FormErrors>;
+  values: Record<string, FormValues>;
+}
+
+export const actions = {
+  async default({ formData, url }: ActionContext) {
+    const { rows, changed } = readGrid(formData, COLUMNS);
+    const values = Object.fromEntries(rows.map((row) => [row.key, row.values]));
+    const errors: Record<string, FormErrors> = {};
+    const valid: { key: string; data: ${n.uno}Data }[] = [];
+    for (const row of changed) {
+      const result = await validate(${forma}, row.values);
+      if (result.ok) valid.push({ key: row.key, data: result.data });
+      else errors[row.key] = result.errors;
+    }
+    if (Object.keys(errors).length) return fail(400, { errors, values } satisfies Failed);
+
+    let current = "";
+    try {
+      await transaction(await db(), async (tx) => {
+        for (const row of valid) {
+          current = row.key;
+          await ${camel(n.update)}(tx, { ...${params}(row.data), ${propiedad(pk)}: key(row.key) });
+        }
+      });
+    } catch (error) {
+      // A repeated UNIQUE value: the error goes under that row's cell.
+      const taken = duplicate(error, new FormData());
+      return fail(409, { errors: { [current]: taken.data.errors }, values } satisfies Failed);
+    }
+    throw redirect(url.pathname + url.search);
+  },
+};
+
+export default function ${n.plural}Grid({ data, form }: { data: Awaited<ReturnType<typeof load>>; form?: Failed }) {
+  const rows = data.rows.map((row, index) => ({
+    index,
+    key: row.key,
+    was: JSON.stringify(row.values),
+    values: form?.values[row.key] ?? row.values,
+    errors: form?.errors[row.key] ?? {},
+  }));
+  type Row = (typeof rows)[number];
+  return view\`
+    <section>
+      <h1>${titulo}</h1>
+      <p><a href="${base}">List</a> · <a href="${base}/new">New ${etiqueta(singular(tabla.name)).toLowerCase()}</a></p>
+      <form method="post">
+        <table class="grid">
+          <thead><tr>${cabeceras}</tr></thead>
+          <tbody>
+            <For each=\${() => rows} key=\${(r: Row) => r.key}
+                 render=\${(r: Row) => view\`<tr>
+               <td><a href=\${\`${base}/\${r.key}\`}>\${r.key}</a><input type="hidden" name=\${\`k\${r.index}\`} value=\${r.key}><input type="hidden" name=\${\`w\${r.index}\`} value=\${r.was}><small class="error">\${r.errors[""] ?? ""}</small></td>
+               ${celdas}
+             </tr>\`}/>
+          </tbody>
+        </table>
+        <button>Save changes</button>
+      </form>
+      <nav>
+        <Show when=\${() => data.page > 1}><a href=\${\`?page=\${data.page - 1}\`}>Previous</a></Show>
+        <Show when=\${() => data.more}><a href=\${\`?page=\${data.page + 1}\`}>Next</a></Show>
+      </nav>
+      <style>
+        .grid input, .grid select { width: 100%; box-sizing: border-box; }
+        .grid input[type="checkbox"] { width: auto; }
+        .grid td { vertical-align: top; }
+        .error { display: block; color: crimson; }
+      </style>
+    </section>\`;
+}
+`;
+}
+
+/** `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, consultasSql, nombres, piscina, recurso, rutas, ScaffoldError, t } from "./generate.js";
+import { analizar, ayudaRejilla, 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
@@ -27,13 +28,17 @@ Genera, a partir de una tabla de las migraciones de brasa:
   src/routes/<tabla>/index.ts     la lista, paginada
   src/routes/<tabla>/new.ts       el alta
   src/routes/<tabla>/[id].ts      la edición y la baja
+  src/routes/<tabla>/grid.ts      todas las filas editables a la vez
+  src/resources/grid.ts           leer lo que manda una grilla, si no existe
   src/pool.ts                     el pool de la base, si no existe
 
 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
@@ -41,10 +46,13 @@ Generates, from a table in the brasa migrations:
   src/routes/<table>/index.ts     the list, paginated
   src/routes/<table>/new.ts       creating
   src/routes/<table>/[id].ts      editing and deleting
+  src/routes/<table>/grid.ts      every row editable at once
+  src/resources/grid.ts           reading what a grid sends, if missing
   src/pool.ts                     the database pool, if missing
 
 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`,
 );
@@ -53,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;
@@ -95,123 +104,226 @@ 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 });
   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 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 hay = consultas.filter((q) => p.salida.queries.some((x) => x.name === q));
+  const reusa = reutilizar && !force && hay.length === consultas.length && existsSync(archivoRecurso);
+
+  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: 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"),
-    pool: join(raiz, "src", "pool.ts"),
+    sql,
+    recurso: archivoRecurso,
+    index: join(dirRutas, "index.ts"),
+    nuevo: join(dirRutas, "new.ts"),
+    editar: join(dirRutas, "[id].ts"),
+    rejilla: join(dirRutas, "grid.ts"),
   };
-  const existentes = Object.entries(archivos).filter(([k, f]) => k !== "pool" && existsSync(f));
-  if (existentes.length && !args.force) {
-    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`),
-    );
+  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, 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 (!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);
+  terminar(p, escritos, t(`Listo: /admin con ${incluidas.length} tablas (${planes.length} nuevas).`, `Done: /admin with ${incluidas.length} tables (${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.1.1",
+  "version": "0.3.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",