ascua-scaffold 0.2.0 → 0.3.0

package/README.md

@@ -83,6 +83,31 @@ un `<form>` de HTML, así que también funciona sin JavaScript.
 - 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
@@ -97,6 +122,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

@@ -765,6 +765,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, 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,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"),
-    rejilla: join(raiz, "src", "routes", carpeta, "grid.ts"),
-    pool: join(raiz, "src", "pool.ts"),
-    ayuda: join(raiz, "src", "resources", "grid.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" && k !== "ayuda" && 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, 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 (!reusa) {
+    contenidos.sql = consultasSql(tabla, a, n);
+    contenidos.recurso = recurso(tabla, a, n, { db: importar(archivoRecurso, p.out), enums });
   }
-  if (!existsSync(archivos.ayuda)) {
-    writeFileSync(archivos.ayuda, ayudaRejilla());
-    escritos.push(archivos.ayuda);
-  }
-  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.2.0",
+  "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",