ascua-scaffold 0.0.0-stage → 0.1.0

package/LICENSE-APACHE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Los autores de Ascua
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,87 @@
-# Temporary Holding Version
+# ascua-scaffold
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+De una tabla a un recurso completo de [Ascua](https://ascua.gitweave.run):
+lista paginada, alta, edición y baja, con el formulario validado en el
+servidor. Un comando, como en Rails o Django, pero con SQL de verdad: lee el
+esquema de tus migraciones con [brasa](https://www.npmjs.com/package/brasa-sql).
+
+```sh
+stil add -D ascua-scaffold brasa-sql   # o npm i -D ascua-scaffold brasa-sql
+stil add pg                            # o mysql2, con "dialect": "mysql"
+stil exec ascua-scaffold products      # o npx ascua-scaffold products
+```
+
+Con esta migración:
+
+```sql
+CREATE TYPE category AS ENUM ('tools', 'books', 'garden');
+
+CREATE TABLE products (
+  id serial PRIMARY KEY,
+  sku text NOT NULL UNIQUE,
+  name text NOT NULL,
+  description text,
+  price numeric(10, 2) NOT NULL,
+  active boolean NOT NULL DEFAULT true,
+  category category NOT NULL DEFAULT 'tools',
+  released_on date,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+```
+
+escribe:
+
+```text
+db/queries/products.sql         ListProducts, GetProduct, CreateProduct, UpdateProduct, DeleteProduct
+src/resources/products.ts       el esquema del formulario, sus campos y las conversiones
+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/pool.ts                     el pool, con las migraciones aplicadas una vez (si no existe)
+```
+
+y vuelve a generar el módulo de brasa con las consultas nuevas.
+
+## Qué genera
+
+- **Consultas en SQL**, en un archivo tuyo: cámbialas como quieras (un
+  `WHERE`, otro orden, un `JOIN`) y `brasa generate` revisa que sigan
+  valiendo. Llevan parámetros `:nombre`, que sirven en Postgres y en MySQL.
+- **Un formulario por columna**, según su tipo: `field.number` para números,
+  `field.checkbox` para booleanos, un `<select>` con `field.choice` para un
+  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`.
+- **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.
+- **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.
+
+Lo que el formulario no sabe editar (JSON, binarios, arreglos) y las columnas
+`created_at` o `updated_at` con `DEFAULT` quedan fuera. Si una columna así es
+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.
+
+## 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`).
+- 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.
+- La conexión sale de `DATABASE_URL`.
+
+## Opciones
+
+```text
+ascua-scaffold <tabla> [--config brasa.json] [--force]
+```
+
+## Licencia
+
+MIT o Apache-2.0, a elección.

package/generate.js

@@ -0,0 +1,619 @@
+/**
+ * De una tabla del esquema de brasa a los archivos de un recurso: consultas,
+ * esquema del formulario y rutas. Sin E/S: recibe la tabla y devuelve
+ * `{ ruta: contenido }`, para poder probarlo sin disco ni base.
+ */
+
+const español = /^es/i.test(process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || "");
+export const t = (es, en) => (español ? es : en);
+
+/** Lo que el formulario sabe editar; el resto (json, binarios, arreglos…) se deja fuera. */
+const EDITABLES = new Set(["integer", "decimal", "number", "boolean", "text", "uuid", "date", "datetime", "time", "enum"]);
+
+/** Columnas de auditoría que la base llena sola: con DEFAULT, no van al formulario. */
+const AUTOMATICAS = new Set(["created_at", "updated_at", "inserted_at", "createdAt", "updatedAt"]);
+
+/** Columnas de texto largo: `<textarea>` en vez de `<input>`. */
+const LARGAS = /^(body|content|description|bio|notes?|text|summary|comment)$/i;
+
+/** Palabras reservadas que no pueden ir sin comillas como nombre de columna o tabla. */
+const RESERVADAS = new Set(
+  "all and any as asc both case check column constraint create default desc distinct do else end false for foreign from grant group having in into is key limit not null offset on or order primary references select table then to true union unique user using when where with".split(
+    " ",
+  ),
+);
+
+/** `list_posts` → `["list", "posts"]`. */
+function palabras(n) {
+  return n
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .split(/[^A-Za-z0-9]+/)
+    .filter(Boolean)
+    .map((p) => p.toLowerCase());
+}
+
+export const pascal = (n) => palabras(n).map((p) => p[0].toUpperCase() + p.slice(1)).join("");
+export const camel = (n) => {
+  const p = pascal(n);
+  return p[0].toLowerCase() + p.slice(1);
+};
+
+/** Singular en inglés, lo justo para nombres de tablas: posts → post, categories → category. */
+export function singular(n) {
+  if (/ies$/i.test(n)) return n.slice(0, -3) + "y";
+  if (/(ss|us|is)$/i.test(n)) return n;
+  if (/(x|ch|sh|ss)es$/i.test(n)) return n.slice(0, -2);
+  if (/s$/i.test(n)) return n.slice(0, -1);
+  return n;
+}
+
+/** `published_at` → `Published at`. */
+function etiqueta(n) {
+  const p = palabras(n).join(" ");
+  return p[0].toUpperCase() + p.slice(1);
+}
+
+/** El nombre en SQL, con comillas solo si hace falta. */
+function sqlNombre(n, mysql) {
+  const simple = mysql ? /^[A-Za-z_][A-Za-z0-9_]*$/ : /^[a-z_][a-z0-9_]*$/;
+  if (simple.test(n) && !RESERVADAS.has(n.toLowerCase())) return n;
+  return mysql ? "`" + n.replace(/`/g, "``") + "`" : '"' + n.replace(/"/g, '""') + '"';
+}
+
+const esIdentificador = (n) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(n);
+const propiedad = (n) => (esIdentificador(n) ? n : JSON.stringify(n));
+const acceso = (n) => (esIdentificador(n) ? `.${n}` : `[${JSON.stringify(n)}]`);
+
+/** Error con un mensaje para quien usa la CLI, no una traza. */
+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 }) {
+  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(
+      tabla.primaryKey.length === 0
+        ? t(`\`${tabla.name}\` no tiene clave primaria`, `\`${tabla.name}\` has no primary key`)
+        : t(`\`${tabla.name}\` tiene una clave primaria compuesta; por ahora solo se genera con una columna`, `\`${tabla.name}\` has a composite primary key; only single-column keys are supported for now`),
+    );
+  }
+  const clave = tabla.columns.find((c) => c.name === tabla.primaryKey[0]);
+  if (!["integer", "text", "uuid"].includes(clave.kind) || clave.array) {
+    throw new ScaffoldError(t(`la clave primaria \`${clave.name}\` es ${clave.sqlType}: se admite entero, texto o uuid`, `primary key \`${clave.name}\` is ${clave.sqlType}: integer, text or uuid are supported`));
+  }
+  const claveAutomatica = clave.hasDefault;
+
+  const editables = [];
+  const fuera = [];
+  for (const c of tabla.columns) {
+    if (c.generated) continue;
+    if (c === clave && claveAutomatica) continue;
+    if (c.hasDefault && AUTOMATICAS.has(c.name)) continue;
+    if (!EDITABLES.has(c.kind) || c.array) {
+      if (!c.nullable && !c.hasDefault) {
+        throw new ScaffoldError(
+          t(
+            `la columna \`${c.name}\` (${c.sqlType}) es obligatoria y el formulario no sabe editarla; dale un DEFAULT o hazla nullable`,
+            `column \`${c.name}\` (${c.sqlType}) is required and the form cannot edit it; give it a DEFAULT or make it nullable`,
+          ),
+        );
+      }
+      fuera.push(c);
+      continue;
+    }
+    if (!esIdentificador(c.name)) {
+      throw new ScaffoldError(t(`la columna \`${c.name}\` no sirve como nombre de parámetro`, `column \`${c.name}\` cannot be used as a parameter name`));
+    }
+    editables.push(c);
+  }
+  // Sin clave automática, la clave se escribe al crear, pero no se cambia al editar.
+  const alCrear = editables;
+  const alEditar = editables.filter((c) => c !== clave);
+  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 };
+}
+
+/** Los nombres de las consultas del recurso. */
+export function nombres(tabla) {
+  const plural = pascal(tabla.name);
+  const uno = pascal(singular(tabla.name));
+  return {
+    plural,
+    uno,
+    list: `List${plural}`,
+    get: `Get${uno}`,
+    create: `Create${uno}`,
+    update: `Update${uno}`,
+    delete: `Delete${uno}`,
+  };
+}
+
+/** El SQL de las cinco consultas. Los parámetros `:nombre` valen en Postgres y en MySQL. */
+export function consultasSql(tabla, a, n) {
+  const q = (x) => sqlNombre(x, a.mysql);
+  const tab = q(tabla.name);
+  const pk = q(a.clave.name);
+  const columnas = a.alCrear.map((c) => q(c.name)).join(", ");
+  const valores = a.alCrear.map((c) => `:${c.name}`).join(", ");
+  const sets = a.alEditar.map((c) => `${q(c.name)} = :${c.name}`).join(",\n    ");
+  const crear =
+    a.mysql
+      ? `-- name: ${n.create} ${a.claveAutomatica ? ":execlastid" : ":exec"}\nINSERT INTO ${tab} (${columnas})\nVALUES (${valores});`
+      : `-- name: ${n.create} :one\nINSERT INTO ${tab} (${columnas})\nVALUES (${valores})\nRETURNING ${pk};`;
+  const actualizar = a.alEditar.length
+    ? `-- name: ${n.update} :execrows\nUPDATE ${tab}\nSET ${sets}\nWHERE ${pk} = :${a.clave.name};\n\n`
+    : "";
+  return (
+    `-- Generated by ascua-scaffold. Yours to edit: it is not generated again.\n\n` +
+    `-- name: ${n.list} :many\nSELECT * FROM ${tab}\nORDER BY ${pk} DESC\nLIMIT :limit OFFSET :offset;\n\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`
+  );
+}
+
+/** El esquema de `field` para una columna. */
+function campo(c, valoresEnum) {
+  const opcional = (s) => (c.nullable ? `field.optional(${s})` : s);
+  switch (c.kind) {
+    case "integer":
+      return opcional("field.number({ integer: true })");
+    case "decimal":
+    case "number":
+      return opcional("field.number()");
+    case "boolean":
+      // Una casilla sin marcar es `false`, nunca nula.
+      return "field.checkbox()";
+    case "enum":
+      return opcional(`field.choice(${valoresEnum})`);
+    case "text":
+      if (/(^|_)e-?mail$/i.test(c.name)) return opcional("field.email()");
+      // Obligatorio solo si la base lo exige y no tiene DEFAULT.
+      return c.nullable ? "field.optional(field.text())" : c.hasDefault ? "field.text({ min: 0 })" : "field.text()";
+    default:
+      // uuid, fechas y horas llegan como texto; la base las valida.
+      return opcional("field.text()");
+  }
+}
+
+/** El control HTML de una columna, dentro del `view` de `…Fields`. */
+function control(c, valoresEnum) {
+  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) {
+    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}"${req}>${vacia}\n` +
+        `          <For each=\${() => ${valoresEnum}} key=\${(v: string) => v}\n` +
+        `               render=\${(v: string) => view\`<option prop:selected=\${${v} === v}>\${v}</option>\`}/>\n` +
+        `        </select>`;
+      break;
+    }
+    case "integer":
+      html = `<input type="number" name="${nombre}" step="1" prop:value=\${${texto}}${req}>`;
+      break;
+    case "decimal":
+    case "number":
+      html = `<input type="number" name="${nombre}" step="any" prop:value=\${${texto}}${req}>`;
+      break;
+    case "date":
+      html = `<input type="date" name="${nombre}" prop:value=\${${texto}}${req}>`;
+      break;
+    case "datetime":
+      html = `<input type="datetime-local" name="${nombre}" prop:value=\${${texto}}${req}>`;
+      break;
+    case "time":
+      html = `<input type="time" name="${nombre}" prop:value=\${${texto}}${req}>`;
+      break;
+    default:
+      if (LARGAS.test(nombre)) html = `<textarea name="${nombre}"${req}>\${${texto}}</textarea>`;
+      else if (/(^|_)e-?mail$/i.test(nombre)) html = `<input type="email" name="${nombre}" prop:value=\${${texto}}${req}>`;
+      else html = `<input name="${nombre}" prop:value=\${${texto}}${req}>`;
+  }
+  return (
+    `      <label>${etiqueta(nombre)}\n        ${html}\n      </label>\n` +
+    `      <p class="error">\${errors${acceso(nombre)} ?? ""}</p>`
+  );
+}
+
+/** Una fila de la base a los textos del formulario. */
+function aTexto(c, fila) {
+  const v = `${fila}${acceso(c.name)}`;
+  switch (c.kind) {
+    case "boolean":
+      return `${v} ? "on" : ""`;
+    case "date":
+      return `${v} == null ? "" : toDate(${v})`;
+    case "datetime":
+      return `${v} == null ? "" : toDateTime(${v})`;
+    default:
+      return `${v} == null ? "" : String(${v})`;
+  }
+}
+
+/**
+ * `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.
+ */
+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 : "";`;
+  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.
+ */
+export function duplicate(error: unknown, formData: FormData) {
+  const e = error as { code?: unknown; detail?: unknown } | null;
+${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. */
+function texts(formData: FormData): FormValues {
+  const values: Record<string, string> = {};
+  for (const [name, value] of formData) if (typeof value === "string") values[name] = value;
+  return values;
+}
+`;
+}
+
+/** `src/resources/<tabla>.ts`: los esquemas, los campos y las conversiones. */
+export function recurso(tabla, a, n, { db, enums }) {
+  const valoresEnum = (c) => (c.values ? (enums.has(c.sqlType) ? `${camel(c.sqlType)}Values` : JSON.stringify(c.values)) : "[]");
+  const importsEnum = [...new Set(a.alCrear.filter((c) => c.kind === "enum" && enums.has(c.sqlType)).map((c) => `${camel(c.sqlType)}Values`))];
+  const usaFechas = a.alEditar.some((c) => c.kind === "date" || c.kind === "datetime");
+  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 aParams = a.alEditar
+    .map((c) => {
+      const v = `data${acceso(c.name)}`;
+      return `    ${propiedad(c.name)}: ${c.nullable && c.kind !== "boolean" ? `${v} ?? null` : v},`;
+    })
+    .join("\n");
+  const aValores = a.alEditar.map((c) => `    ${propiedad(c.name)}: ${aTexto(c, "row")},`).join("\n");
+
+  const fechas = usaFechas
+    ? `
+const pad = (n: number) => String(n).padStart(2, "0");
+/** A \`Date\` as the value of \`<input type="date">\`. */
+const toDate = (d: Date) => \`\${d.getFullYear()}-\${pad(d.getMonth() + 1)}-\${pad(d.getDate())}\`;
+/** A \`Date\` as the value of \`<input type="datetime-local">\`, in local time. */
+const toDateTime = (d: Date) => \`\${toDate(d)}T\${pad(d.getHours())}:\${pad(d.getMinutes())}\`;
+`
+    : "";
+
+  const nuevoEsquema = conClave
+    ? `
+/** The new ${singular(tabla.name)} form: the same fields plus the key, which is not edited later. */
+export const New${n.uno}Form = fields({
+  ${propiedad(a.clave.name)}: ${campo(a.clave, "[]")},
+  ...shape,
+});
+`
+    : `
+/** Creating asks for the same fields: the key comes from the database. */
+export const New${n.uno}Form = ${n.uno}Form;
+`;
+
+  const cuerpo = conClave
+    ? `<Show when=\${() => props.withKey === true}>\n${controles([a.clave]).replace(/^/gm, "  ")}\n      </Show>\n${controles(a.alEditar)}`
+    : controles(a.alEditar);
+
+  return `// Generated by ascua-scaffold from the \`${tabla.name}\` table. Yours to edit:
+// it is not generated again.
+import type { Infer } from "ascua";
+import { fail, field, fields } from "vite-plugin-ascua/site";
+
+import { ${[...importsEnum, `type ${n.get}Row`].join(", ")} } from "${db}";
+
+const shape = {
+${esquema}
+};
+
+/** What the ${singular(tabla.name)} form sends, validated on the server. */
+export const ${n.uno}Form = fields(shape);
+${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>>;
+${fechas}
+/** The form data as query parameters: empty optional fields become NULL. */
+export function ${camel(n.uno)}Params(data: ${n.uno}Data) {
+  return {
+${aParams}
+  };
+}
+
+${duplicado(a.mysql)}
+/** A row as the values of the form. */
+export function ${camel(n.uno)}Values(row: ${n.get}Row): FormValues {
+  return {
+${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" : ""} }) {
+  const { values, errors } = props;
+  return view\`
+    <div class="fields">
+${cuerpo}
+      <p class="error">\${errors[""] ?? ""}</p>
+      <style>
+        .fields { display: grid; gap: .25rem; max-width: 32rem; }
+        .fields label { display: grid; gap: .25rem; }
+        .error { color: crimson; margin: 0; min-height: 1.25em; }
+      </style>
+    </div>\`;
+}
+`;
+}
+
+/** Cómo se convierte el texto de la URL en el tipo de la clave. */
+function claveDeUrl(a) {
+  if (a.clave.kind === "integer") {
+    // `int8` entra como texto para no perder precisión; los demás, como número.
+    const ancho = a.clave.sqlType === "int8" && !a.mysql;
+    return { guarda: `/^\\d+$/.test(id)`, valor: ancho ? "id" : "Number(id)" };
+  }
+  if (a.clave.kind === "uuid") return { guarda: `/^[0-9a-f-]{36}$/i.test(id)`, valor: "id" };
+  return { guarda: "id !== \"\"", valor: "id" };
+}
+
+/** Las tres rutas del recurso. */
+export function rutas(tabla, a, n, { db, pool, resource, base }) {
+  const { guarda, valor } = claveDeUrl(a);
+  const pk = a.clave.name;
+  const fila = (r) => `${r}${acceso(pk)}`;
+  const titulo = etiqueta(tabla.name);
+  const uno = etiqueta(singular(tabla.name)).toLowerCase();
+  const forma = `${n.uno}Form`;
+  const params = `${camel(n.uno)}Params`;
+  const values = `${camel(n.uno)}Values`;
+  const campos = `${n.uno}Fields`;
+
+  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("");
+
+  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}";
+
+const PAGE = 50;
+
+export const title = "${titulo}";
+
+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 };
+}
+
+/** How a value of any column reads in a cell. */
+function show(value: unknown): string {
+  if (value == null) return "";
+  if (value instanceof Date) return value.toLocaleString();
+  if (typeof value === "boolean") return value ? "yes" : "no";
+  return String(value);
+}
+
+export default function ${n.plural}({ data }: { data: Awaited<ReturnType<typeof load>> }) {
+  return view\`
+    <section>
+      <h1>${titulo}</h1>
+      <p><a href="${base}/new">New ${uno}</a></p>
+      <table>
+        <thead><tr>${cabeceras}</tr></thead>
+        <tbody>
+          <For each=\${() => data.rows} key=\${(r: ${n.list}Row) => String(${fila("r")})}
+               render=\${(r: ${n.list}Row) => view\`<tr><td><a href=\${\`${base}/\${${fila("r")}}\`}>\${String(${fila("r")})}</a></td>${celdas}</tr>\`}/>
+        </tbody>
+      </table>
+      <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>
+    </section>\`;
+}
+`;
+
+  const nuevaForma = `New${n.uno}Form`;
+  const datos = a.claveAutomatica
+    ? `${params}(result.data)`
+    : `{ ...${params}(result.data), ${propiedad(pk)}: result.data${acceso(pk)} }`;
+  // 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}}\`);`;
+  const despuesDeCrear = a.mysql
+    ? a.claveAutomatica
+      ? intento("id", "id")
+      : intento(null, `result.data${acceso(pk)}`)
+    : intento("row", fila("row!"));
+
+  const nuevo = `// Generated by ascua-scaffold. Yours to edit: it is not generated again.
+import { fail, redirect, validate, type ActionContext, type FormResult } from "vite-plugin-ascua/site";
+
+import { ${camel(n.create)} } from "${db.nested}";
+import { db } from "${pool.nested}";
+import { ${nuevaForma}, ${campos}, ${params}, duplicate } from "${resource.nested}";
+
+export const title = "New ${uno}";
+
+export const actions = {
+  async default({ formData }: ActionContext) {
+    const result = await validate(${nuevaForma}, formData);
+    if (!result.ok) return fail(400, result);
+    ${despuesDeCrear}
+  },
+};
+
+export default function New${n.uno}({ form }: { 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}"}/>
+        <button>Create</button>
+      </form>
+      <p><a href="${base}">Back</a></p>
+    </section>\`;
+}
+`;
+
+  const actualizar = a.alEditar.length
+    ? `
+  async default({ params, formData }: ActionContext<Params>) {
+    const id = key(params.id);
+    const result = await validate(${forma}, formData);
+    if (!result.ok) return fail(400, result);
+    let changed;
+    try {
+      changed = await ${camel(n.update)}(await db(), { ...${params}(result.data), ${propiedad(pk)}: id });
+    } catch (error) {
+      return duplicate(error, formData);
+    }
+    if (changed === 0) throw notFound();
+    throw redirect("${base}");
+  },`
+    : "";
+
+  const editar = `// Generated by ascua-scaffold. Yours to edit: it is not generated again.
+import { fail, notFound, redirect, validate, type ActionContext, type FormResult } from "vite-plugin-ascua/site";
+
+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}";
+
+type Params = { id: string };
+
+/** The key from the URL, or a 404 if it cannot be one. */
+function key(id: string) {
+  if (!(${guarda})) throw notFound();
+  return ${valor};
+}
+
+export const title = ({ id }: Params) => \`${etiqueta(singular(tabla.name))} \${id}\`;
+
+export async function load({ id }: Params) {
+  const row = await ${camel(n.get)}(await db(), { ${propiedad(pk)}: key(id) });
+  if (!row) throw notFound();
+  return row;
+}
+
+export const actions = {${actualizar}
+  async delete({ params }: ActionContext<Params>) {
+    await ${camel(n.delete)}(await db(), { ${propiedad(pk)}: key(params.id) });
+    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;
+  return view\`
+    <section>
+      <h1>${etiqueta(singular(tabla.name))} \${String(${fila("data")})}</h1>
+      ${a.alEditar.length ? `<form method="post">
+        <${campos} values=\${failed?.values ?? ${values}(data)} errors=\${failed?.errors ?? {}}/>
+        <button>Save</button>
+      </form>
+      ` : ""}<form method="post" action="?/delete">
+        <button>Delete</button>
+      </form>
+      <p><a href="${base}">Back</a></p>
+    </section>\`;
+}
+`;
+
+  return { index, nuevo, editar };
+}
+
+/** `src/pool.ts`: un pool para todo el servidor, con las migraciones aplicadas una vez. */
+export function piscina({ mysql, migrate, db }) {
+  if (mysql) {
+    return `// Generated by ascua-scaffold. Yours to edit: it is not generated again.
+import mysql from "mysql2/promise";
+${migrate ? `\nimport { migrate } from "${db}";\n` : ""}
+/** One pool for the whole server, from DATABASE_URL. */
+export const pool = mysql.createPool(process.env.DATABASE_URL ?? "mysql://root@127.0.0.1/app");
+${
+  migrate
+    ? `
+let ready: Promise<typeof pool> | undefined;
+
+/** The pool, once the pending migrations are applied. A failure is retried on the next request. */
+export function db(): Promise<typeof pool> {
+  ready ??= migrate(pool).then(
+    () => pool,
+    (error) => {
+      ready = undefined;
+      throw error;
+    },
+  );
+  return ready;
+}
+`
+    : `
+/** The pool. Migrations are applied by hand. */
+export async function db(): Promise<typeof pool> {
+  return pool;
+}
+`
+}`;
+  }
+  return `// Generated by ascua-scaffold. Yours to edit: it is not generated again.
+import pg from "pg";
+${migrate ? `\nimport { migrate } from "${db}";\n` : ""}
+/** One pool for the whole server: DATABASE_URL, or the PG* variables. */
+export const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL });
+${
+  migrate
+    ? `
+let ready: Promise<pg.Pool> | undefined;
+
+/** The pool, once the pending migrations are applied. A failure is retried on the next request. */
+export function db(): Promise<pg.Pool> {
+  ready ??= migrate(pool).then(
+    () => pool,
+    (error) => {
+      ready = undefined;
+      throw error;
+    },
+  );
+  return ready;
+}
+`
+    : `
+/** The pool. Migrations are applied by hand. */
+export async function db(): Promise<pg.Pool> {
+  return pool;
+}
+`
+}`;
+}

package/index.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+/**
+ * ascua-scaffold: de una tabla a un recurso con lista, alta, edición y baja.
+ *
+ *   stil exec ascua-scaffold posts
+ *   npx ascua-scaffold posts
+ *
+ * Lee el esquema con el `brasa-sql` del proyecto (las migraciones de
+ * `brasa.json`), escribe las consultas, vuelve a generar el módulo de brasa y
+ * escribe el esquema del formulario y las rutas. Sin dependencias propias.
+ */
+
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+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";
+
+const AYUDA = t(
+  `Uso: ascua-scaffold <tabla> [opciones]
+
+Genera, a partir de una tabla de las migraciones de brasa:
+  db/queries/<tabla>.sql          List, Get, Create, Update y Delete
+  src/resources/<tabla>.ts        el esquema del formulario y sus campos
+  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/pool.ts                     el pool de la base, si no existe
+
+Opciones:
+  --config <ruta>   el brasa.json (por defecto, el del directorio actual)
+  --force           reescribe los archivos que ya existan
+  -h, --help        esta ayuda`,
+  `Usage: ascua-scaffold <table> [options]
+
+Generates, from a table in the brasa migrations:
+  db/queries/<table>.sql          List, Get, Create, Update and Delete
+  src/resources/<table>.ts        the form schema and its fields
+  src/routes/<table>/index.ts     the list, paginated
+  src/routes/<table>/new.ts       creating
+  src/routes/<table>/[id].ts      editing and deleting
+  src/pool.ts                     the database pool, if missing
+
+Options:
+  --config <path>   the brasa.json (default: the one in the current directory)
+  --force           overwrite files that already exist
+  -h, --help        this help`,
+);
+
+const POR_DEFECTO = { dialect: "postgres", migrations: "db/migrations", queries: "db/queries", out: "src/db.ts", migrate: true };
+
+/** `["posts", "--force"]` → `{ table: "posts", force: true }`. */
+export function leerArgumentos(argv) {
+  const salida = { table: undefined, config: "brasa.json", force: 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 === "--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;
+    else throw new ScaffoldError(t(`opción desconocida: ${a}`, `unknown option: ${a}`));
+  }
+  return salida;
+}
+
+/** El `brasa-sql` del proyecto: el mismo que genera su módulo. */
+async function cargarBrasa(raiz) {
+  const require = createRequire(join(raiz, "package.json"));
+  let entrada;
+  try {
+    entrada = require.resolve("brasa-sql");
+  } catch {
+    throw new ScaffoldError(t("falta brasa-sql en el proyecto: stil add -D brasa-sql", "brasa-sql is missing from the project: npm i -D brasa-sql"));
+  }
+  const brasa = await import(pathToFileURL(entrada).href);
+  const bin = join(dirname(entrada), "bin", "brasa.js");
+  return { compile: brasa.compile, bin };
+}
+
+function leerSql(dir) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((n) => n.endsWith(".sql"))
+    .sort()
+    .map((n) => ({ name: relative(process.cwd(), join(dir, n)), content: readFileSync(join(dir, n), "utf8") }));
+}
+
+/** Una importación relativa de TypeScript con extensión `.js`, como pide `nodenext`. */
+function importar(desde, hacia) {
+  let r = relative(dirname(desde), hacia).replace(/\\/g, "/").replace(/\.ts$/, ".js");
+  if (!r.startsWith(".")) r = `./${r}`;
+  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;
+  }
+
+  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 });
+  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"));
+  }
+
+  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 });
+  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));
+  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();
+  // 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 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"),
+  };
+  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`),
+    );
+  }
+
+  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}`,
+  });
+  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,
+  };
+  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.pool)) {
+    writeFileSync(archivos.pool, piscina({ mysql, migrate: config.migrate, db: importar(archivos.pool, out) }));
+    escritos.push(archivos.pool);
+  }
+
+  // El módulo de brasa, con las consultas nuevas.
+  const generado = spawnSync(process.execPath, [brasa.bin, "generate", "--config", rutaConfig], { cwd: 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 deps = { ...paquete.dependencies, ...paquete.devDependencies };
+  const faltan = (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.`));
+  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")))) {
+    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'));
+  }
+  return 0;
+}
+
+function leer(f) {
+  return existsSync(f) ? readFileSync(f, "utf8") : "";
+}
+
+if (process.argv[1] && realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url))) {
+  main().then(
+    (codigo) => process.exit(codigo),
+    (error) => {
+      if (error instanceof ScaffoldError) {
+        console.error(`ascua-scaffold: ${error.message}`);
+        process.exit(1);
+      }
+      throw error;
+    },
+  );
+}

package/package.json

@@ -1,6 +1,25 @@
 {
   "name": "ascua-scaffold",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.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",
+  "license": "MIT OR Apache-2.0",
+  "type": "module",
+  "bin": {
+    "ascua-scaffold": "index.js"
+  },
+  "files": ["index.js", "generate.js", "README.md", "LICENSE-MIT", "LICENSE-APACHE"],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "vitest": "^5.0.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}