Ir al contenido

Upgrading

Actualización de 0.30 a 0.31

Desde 0.31

0.31 hace que el backend sea Postgres-first. Las tablas que declaras con defineTable en backend/schema/ son lo único que el backend conoce sobre tus datos; lo que muestra el panel de administración sobre ellas reside en el frontend. Casi cada entrada a continuación es una consecuencia de esa división, y casi todo se realiza automáticamente con un solo comando.

  1. Actualiza primero cada paquete @rebasepro, en cada paquete del workspace, para que los tipos que lee el codemod sean los de 0.31: pnpm -r up "@rebasepro/*@0.31.0", luego pnpm install. Un proyecto en una versión anterior a 0.30 debe aplicar primero los cambios de código de las guías intermedias (Actualización), y cumplir con los requisitos mínimos de toolchain de 0.31 — Node 22.22, TypeScript 6, React 19.2.7, React Router 8, Vite 8 (la lista): el codemod carga un config/ de 0.20–0.29 y su comprobación SQL pasa, pero esa comprobación compara el compilador de 0.31 consigo mismo — solo el paso 7, contra tu base de datos, demuestra que el DDL generado coincide con el de tu base de datos.

  2. Haz commit y luego ejecuta el codemod en modo de prueba (dry run): rebase migrate collections-to-tables --dry-run. Imprime los archivos que escribiría, lo que rechaza (con archivo y línea), las notas y los pasos manuales, sin escribir nada. Corrige primero en config/ lo que rechace.

  3. Ejecútalo de verdad: rebase migrate collections-to-tables. Escribe backend/schema/, frontend/src/cms/ (con ui-config.json), los módulos de backend/ y los archivos del proyecto, añade rebaseBackendGuard() al vite.config.ts del scaffold, reescribe tus llamadas al SDK, mueve las importaciones de identificadores que 0.31 trasladó a otro paquete (sección 135), y comprueba que el SQL generado sea idéntico byte por byte — o restaura todos los archivos. Consulta la sección 108.

  4. Lee la última sección de su salida, “Review before deploying: these rules change meaning”, y decide sobre cada regla que enumera (más abajo).

  5. Realiza los pasos manuales que imprime, en orden. Cada uno indica su archivo, y la mayoría incluye el fragmento de código a escribir: el montaje de <RebaseCMS> con tableCustomizations y uiConfig cuando tu App.tsx no es el del scaffold (o el panel está montado en otro módulo, el cual el paso especifica), rebaseBackendGuard() cuando tu vite.config.ts no lo es y en cada otra aplicación estática de rebase.json (sección 130), hooks globales, una importación de un identificador que 0.31 eliminó (sección 135), y rebase skills install cuando el proyecto contiene habilidades de agente (sección 128). Ejecuta pnpm install cuando la salida liste “Dependencies added”. Luego lee dos listas en la sección del SDK de la salida:

    • “Rewritten by name — review”: llamadas a .collection( sobre un receptor sin tipo (any), reescritas porque el receptor se llama dataAsAdmin, o es .data con un nombre literal de tabla; el miembro collection de un tipo contenido en un slot data / dataAsAdmin; y dobles de prueba (test doubles). Comprueba que cada uno pertenezca al SDK.
    • “Left unchanged — check each”: llamadas a .collection( que el codemod no pudo verificar que pertenecieran al SDK, como una llamada a través de un tipo declarado por tu propio proyecto. Una llamada que quede aquí y que sí sea del SDK fallará en tiempo de ejecución en 0.31: cámbiala a mano a .table(. El código que comprueba si collection existe (typeof data.collection === "function") es un paso manual: en 0.31 tomará silenciosamente la otra rama.

    Un archivo confirmado como salida de compilación (un .js empaquetado o minificado) nunca se edita: se lista para que lo reconstruyas después de migrar, y reemplaces cualquier copia vendored del cliente con la compilación de 0.31. Los pasos repetidos de un mismo tipo se imprimen una sola vez, listando cada archivo y línea correspondientes; --json mantiene cada paso por separado. Luego lee Qué cambiaron los proyectos a mano: las modificaciones que proyectos reales aún tuvieron que hacer tras estos pasos.

  6. Ejecuta la línea git rm que imprimió el codemod una vez revisado el diff y cuando rebase migrate collections-to-tables --check pase con éxito: git rm -r config/collections … y el cableado que se movió a backend/, o git rm -r config cuando no quede nada propio allí (sección 109). Los siguientes tres pasos requieren haber hecho esto: generate-sdk, db push, doctor y verify rechazan proyectos que aún tengan config/collections.

  7. rebase generate-sdk — los nombres del módulo generado han cambiado (sección 115).

  8. Contra tu base de datos, ejecuta rebase db push --dry-run y espera “No changes: the database already matches these tables.”, luego rebase doctor --policies y espera que no haya discrepancias en las políticas (policy drift). La comprobación SQL del codemod demuestra que la conversión es fiel; estas dos lo demuestran contra la base de datos real, y cualquier diferencia de políticas listada por cualquiera de ellas representa un cambio en quién puede acceder a qué.

  9. rebase verify — ahora también lee frontend/src/cms: una personalización que hace referencia a una tabla o campo inexistente, una columna requerida omitida en el formulario, un rebaseBackendGuard() faltante, un ui-config.json no pasado a <RebaseCMS>.

  10. Reconstruye y despliega. Un bundle compilado antes de 0.31 no arrancará en un runtime 0.31 (sección 112). El primer arranque re-estampa la versión del esquema de la base de datos una vez (sección 113).

Ejecuta rebase migrate collections-to-tables --check en CI hasta que config/ haya desaparecido: verifica que las tablas migradas sigan renderizando el mismo SQL que las colecciones de las que provienen, y sale con código 1 mientras haya una regla listada bajo “Review before deploying” sin confirmar — pasa --accept-rule-changes una vez que las hayas revisado.

Revisar antes de desplegar: estas reglas cambian de significado

Sección titulada «Revisar antes de desplegar: estas reglas cambian de significado»

El codemod traslada cada regla de seguridad tal como está escrita, y cada una conserva el nombre de su política. Pero el compilador de 0.30 leía solo la primera entre condition, using, access: "public" y ownerField, y no reconocía ningún otro valor de access, por lo que cuatro estructuras de reglas ahora otorgan permisos distintos. Dos de ellas amplían el acceso:

La regla 0.30 otorgaba 0.31 otorga
un simple access: "authenticated" (sin roles) nada cualquier llamador autenticado, incluidos invitados amplía
access + check, sin condition, en select / update / delete / all ninguna fila existente toda fila existente, a los llamadores en access amplía
access: "authenticated" + condition cualquiera que coincida con condition solo llamadores autenticados que coincidan con ella restringe
access: "authenticated" + check, en insert cualquiera que inserte una fila coincidente solo llamadores autenticados restringe

La más común es la primera. Escribe access: "registered" para admitir únicamente llamadores con una cuenta (no invitados anónimos), o elimina la regla para seguir sin conceder nada. access con roles, y un condition de objeto plano, conservan su significado original y no se listan.

El codemod también rechaza cualquier regla que el compilador de 0.31 rechace: aquellas que combinen cláusulas excluidas por el tipo SecurityRule (access junto a ownerField, using o withCheck; ownerField junto a using, withCheck, condition o check; condition o check junto a using o withCheck), y aquellas con un valor inválido de access, mode, operation(s) o roles — un "restrictive" mal escrito solía compilarse como permisivo. Consulta Reglas de seguridad.

  • Lo que GET /api/schema/tables devuelve a un usuario. Los administradores y quienes posean schema:read obtienen todas las tablas. Cualquier otro usuario autenticado, incluidos los invitados, obtiene solo las tablas a las que sus roles tienen acceso, con solo las reglas aplicables a ellos; se descartan las relaciones con otras tablas y se retienen las flags de hooks. Un frontend que leía la descripción de otra tabla como usuario regular recibirá menos información; schemaTables: { persons: "all" } en las opciones del backend restaura la descripción completa. Consulta Endpoints.
  • Los nombres de las relaciones son exactos, y las claves foráneas de tipo big-integer son números (sección 131).
  • El historial se sirve enmascarado (sección 132).
  • Los nombres de las herramientas MCP y el payload de la vista cambian juntos para el conector alojado y los entornos de ejecución a los que llega (sección 122).
  • Restringido a propósito. Las marcas de auditoría (columnas .onCreateNow() / .onUpdateNow()) quedan ocultas de las columnas de lista del panel por defecto: una lista migrada que mostraba created_at pierde esa columna hasta que declares fields: { created_at: { hidden: false } } en su customizeTable. El codemod rechaza, indicando el motivo: arrays JSON de tuplas, un vector / binary / reference dentro de un mapa, databaseId en una colección Postgres, isId: "cuid", una relación única isId y disableDefaultPolicies: true sin reglas. Se rechaza una relación de una sola columna hacia una tabla con clave compuesta (debe declararse con rel.via()). Las etiquetas de OpenAPI se toman del slug, no del nombre para mostrar. rebase schema introspect omite tablas sin clave primaria explicando la razón (un servidor que introspecciona la base de datos aún la sirve). Una vista plana que declara roles genera un error de compilación; el codemod la descarta con una nota.
  • Lo que los proyectos reales aún cambiaron a mano — requisitos mínimos de toolchain, ({ entity }) en código de administración, inclusiones de relaciones renombradas, objetos de colección modificados en tiempo de ejecución, llamadas al SDK en receptores sin tipo: Qué cambiaron los proyectos a mano.
  • Restauración a otro clúster. El sello de las políticas default-admin genera un hash de los OID de roles; por lo tanto, tras un volcado o restauración puntual en un clúster diferente, el primer db push o arranque vuelve a crear esas políticas una vez, con los mismos nombres y el mismo SQL.
Antes Ahora Dónde permanece “collection”
una colección en config/collections/ una tabla en backend/schema/ (defineTable) —
properties columns (col.*) y relations (rel.*) —
securityRules, defaultSecurityRules rls (requerido), defaultRls —
callbacks, Property.callbacks hooks, el .transform() de una columna —
el bloque admin customizeTable en frontend/src/cms/ —
data.collection(slug) data.table(slug) —
lo que dibuja el panel de administración una colección: una tabla tal como la muestra el panel, o una colección de Firestore el CMS: CollectionPanel, el Collection Editor, externalCollections

108. Las tablas en backend/schema reemplazan a config/collections — ejecuta el codemod primero

Sección titulada «108. Las tablas en backend/schema reemplazan a config/collections — ejecuta el codemod primero»

A quién afecta: a todos los proyectos con un directorio config/collections/.

Qué cambió: el backend solo lee backend/schema/index.ts y los resultados de defineTable, defineAuthTable y defineView que este exporta. Ningún componente lee ya los archivos defineCollection: el runtime, cada comando de la CLI y la validación de rebase.json rechazan un proyecto que conserve config/collections, indicando el comando que figura abajo. Se requiere rls en cada tabla — una lista de reglas, "admin-only" o "inherit" para el defaultRls que exporta el index — y disableDefaultPolicies pasa a ser defaultPolicies: false.

Qué hacer:

rebase migrate collections-to-tables # or --dry-run first

Escribe una tabla por colección, haciendo explícita cada columna física en su posición original (de modo que se escribe la columna de clave de un belongsTo), el index con defaultRls a partir de defaultSecurityRules, un customizeTable para cada colección cuya presentación no fuera la predeterminada, y archivos defineFirestoreCollection para colecciones de Firestore. Los callbacks de una colección pasan a ser los hooks de su tabla y los .transform() de sus columnas; los callbacks globales que exportaba config/index.ts son un paso manual (sección 109). Luego vuelve a leer el resultado a través del nuevo pipeline: el DDL, las políticas, las búsquedas, vectores, triggers, vistas y el esquema de Drizzle deben ser idénticos byte a byte a lo que generaban las colecciones, o de lo contrario restaura todos los archivos y finaliza con código 1 mostrando el diff.

También traslada lo que antes requería trabajo manual:

  • Callbacks construidos mediante un helper (callbacks: softDeleteCallbacks(...) o un objeto de callbacks importado) pasan a ser hooks: con la misma expresión, y las funciones del helper se convierten en propiedades de hook de tabla donde están escritas (el codemod sigue importaciones relativas, declaraciones const, lecturas de propiedades y un único return). Si no puede seguir el helper, un paso indica los hooks que se deben revisar.
  • Un storagePath funcional se migra en dos partes: la función pasa a ser el storage.path de la personalización, para que el panel siga eligiendo el destino de la subida, y la plantilla path de la columna toma la forma de las claves que devuelve — el texto estático de su template literal reemplazando cada ${…} por {path} (`${owner}/cv` → {path}/cv). Ahora el servidor aplica maxBytes y accept de la columna a cualquier subida cuya clave coincida con esa plantilla, no solo a las que nombren la columna, por lo que los límites son más estrictos que en 0.30. Una función cuyo resultado carezca de texto estático será rechazada: añade texto estático primero.
  • Un policy.existsIn({ collection }) de 0.30 conserva su tabla, y auth: { collection: usersCollection } en un entrypoint de backend personalizado se descarta (la tabla definida con defineAuthTable pasa a ser la tabla de autenticación). La opción de arranque collections pasa a ser schemaDir.
  • Un constructor dynamicProps devuelve una personalización de campo con claves planas en 0.31 ({ readOnly: true }, en lugar de { admin: { readOnly: true } }). El codemod reescribe los constructores cuyos retornos sean objetos literales, en línea o en un módulo compartido, y lista los demás.
  • La presentación propagada mediante spread desde un objeto compartido se transfiere a la personalización (….dynamicProps); la presentación calculada por una función envoltorio se reporta como un paso para verificar, sin rechazar el proyecto. La ruta de un componente se resuelve respecto al módulo que la escribió, y un valor calculado cuando se carga config/ (new Date(), Date.now(), una lectura del entorno) se traslada como su expresión, nunca congelado al valor de la ejecución.
  • Las colecciones de Firestore creadas por una función (un getAllFirestoreCollections() que la aplicación propaga en el panel) se convierten a defineFirestoreCollection una a una cuando el archivo de una colección contiene su literal; un paso por constructor lista el resto y la estructura a escribir, y otro paso lista cualquier referencia escrita fuera de un literal convertido, que aún mantendría path.
  • Las importaciones de config/ mediante un alias de ruta (una entrada paths en tsconfig, un resolve.alias de Vite) se reescriben o listan como las relativas, y un storageAuthorize reexportado por config/index.ts se mueve a backend/storage.ts.
  • Una relación renombrada a <key>Relation conserva su etiqueta, columna de lista y título: la personalización referencia a la nueva clave. El código que la incluya no se actualiza automáticamente (qué cambiar).

Todo lo que no pueda trasladarse con exactitud se rechaza indicando archivo y línea, sin escribir nada: colecciones construidas llamando a una función, spreads o accessors que no se puedan desglosar, motores distintos de Postgres o Firestore, o un archivo de salida existente con contenido diferente (muévelo o usa --force). Un árbol de git sucio o un proyecto fuera de git también son rechazados, para que la migración constituya un único diff revisable. --json imprime el informe completo para scripts o agentes. Consulta rebase migrate y Tablas.

Las tablas que genera declaran sus columnas siguiendo la sintaxis de pg-core de Drizzle — col.varchar({ length: 160 }), col.timestamp({ withTimezone: true }), col.text().array(), pgEnum(...), .default(sql`…`), .generatedByDefaultAsIdentity() —, por lo que su salida no requiere nada más; consulta Columnas. Una tabla escrita a mano para una versión previa de 0.31 con la sintaxis anterior (col.timestamptz(), col.varchar(160), col.array(col.text()), col.enum(values, { name }), .defaultSql(), .identity(), .column("…")) ya no compila: tooling/scripts/drizzle-sweep.mts en el repositorio de Rebase la convierte, reescribiendo únicamente las cadenas de builders, y con --verify comprueba que cada tabla convertida compile al mismo descriptor (npx tsx drizzle-sweep.mts --verify backend/schema).

El paso sdk-calls subsiguiente también reescribe los orígenes de las reglas: existsIn({ collection }) y membership: { collection } pasan a ser table (sección 123); --skip-sdk-calls omite esto también. Lo pendiente se muestra como pasos manuales numerados, y cuando el proyecto tiene habilidades de agente instaladas, el último paso indica la línea rebase skills install para actualizarlas (sección 128). Un rebase migrate sin argumentos imprime la ayuda para ambos subcomandos.

A quién afecta: a todos los proyectos — config/ era un workspace independiente.

0.31 deja de leer config/collections; no prohíbe config/. El codemod elimina lo que Rebase leía — los archivos de colección y el cableado que traslada a backend/ (resources.ts, storage.ts, generated/register.ts, y las reexportaciones correspondientes en config/index.ts) — y mantiene tus propios módulos en config/ intactos, importables como siempre: config/ sigue siendo un paquete de workspace y el backend continúa compilando ../config/**/*. Solo se reescriben las importaciones de lo que se elimina: un archivo de colección importado por código de backend apuntará al módulo de la tabla (un paso lista los usos que lo leían como objeto); importado por código de frontend, se convierte en una importación de tipo de la tabla si solo se usaba como tipo, o genera un paso indicando la personalización; un helper dentro de config/collections se copia junto al código que lo requiere.

Qué cambió: lo que residía junto a las colecciones se traslada a backend/:

Antes Ahora
config/resources.ts backend/resources.ts
config/storage.ts, storageAuthorize desde config/index.ts backend/storage.ts
callbacks exportados desde config/index.ts hooks exportados desde backend/hooks.ts (TableHooks: table en lugar de collection, values en lugar de row)
config/generated/register.ts backend/generated/register.ts
config en rebase.json, usersCollection tables (por defecto backend/schema); la tabla de autenticación es la declarada con defineAuthTable

El runtime solo lee storageAuthorize y hooks de esos módulos; cualquier otra exportación se notificará durante el arranque. El frontend debe importar backend/** únicamente como tipos — pnpm check:frontend-backend-imports rechaza importaciones de valores, las cuales enviarían código de servidor al navegador.

Qué hacer: el codemod traslada resources.ts, storage.ts y el registro, y reescribe rebase.json, package.json, pnpm-workspace.yaml y backend/tsconfig.json. Los callbacks globales constituyen un paso manual indicado en la salida: muévelos a backend/hooks.ts manualmente, y añade hooks.ts al include de backend/tsconfig.json para que tsc lo verifique. Luego ejecuta la línea git rm provista: git rm -r config/collections …, o git rm -r config cuando no quede nada propio.

110. Las opciones de arranque y los hooks hacen referencia a tablas

Sección titulada «110. Las opciones de arranque y los hooks hacen referencia a tablas»

A quién afecta: a un backend inicializado manualmente (initializeRebaseBackend, createRebaseBackend), y al código que vincula hooks tras el arranque.

Qué cambió:

Antes Ahora
collections, collectionsDir tables, defaultRls, schemaDir
callbacks hooks
auth.collection eliminado: la tabla defineAuthTable dentro de tables
backend.setCollectionCallbacks(slug, cb) backend.setTableHooks(slug, hooks)
hook props collection, row table (el descriptor), values
composeCallbacks composeTableHooks desde @rebasepro/common
openRebase({ collections, callbacks }) openRebase({ tables, hooks }), con tables desde compileSchema([...])
OpenedRebase.collections; la variable collections en rebase console .tables; tables
await initializeRebaseBackend({ app, server, collectionsDir: "./config/collections", callbacks });
await initializeRebaseBackend({ app, server, schemaDir: path.resolve(__dirname, "../schema"), hooks });

Los hooks vinculados a un objeto de colección pasado en un punto de llamada ya no se ejecutan: el driver ejecuta los hooks de las tablas que sirve, por lo que deben vincularse con setTableHooks.

Qué hacer: rebase migrate sdk-calls reescribe setCollectionCallbacks y adapta las propiedades de los hooks, listando además cada objeto de opciones del backend que deba actualizarse manualmente. Un script que abra los datos compila sus tablas:

const rebase = await openRebase({ databaseUrl, collections, callbacks });
const rebase = await openRebase({ databaseUrl, tables: compileSchema([products, orders]), hooks });

Consulta Scripts. Consulta Información general del backend y Hooks globales.

111. El panel de administración renderiza las tablas que sirve el servidor

Sección titulada «111. El panel de administración renderiza las tablas que sirve el servidor»

A quién afecta: a todo frontend que monte <RebaseCMS>.

Qué cambió: <RebaseCMS collections> desaparece. El panel muestra cada tabla que el backend sirve en GET /api/schema/tables, sin necesidad de un archivo por tabla, seguido de externalCollections (Firestore). tableCustomizations recibe los objetos customizeTable procedentes de frontend/src/cms/. Se eliminan el plugin de colecciones de Vite y virtual:rebase-collections. CollectionsProvider recibe las mismas tres entradas (tableCustomizations, externalCollections, tables).

import { collections } from "virtual:rebase-collections";
<RebaseCMS collections={collections}/>
import { postsCms } from "./cms/posts";
<RebaseCMS tableCustomizations={[postsCms]}/>

Qué hacer: el codemod genera frontend/src/cms/index.ts, que exporta tableCustomizations (y externalCollections), y lo monta directamente en el App.tsx del scaffold; un App.tsx no reconocido, el plugin en vite.config.ts y la declaración del módulo virtual se detallan en los pasos manuales listados. Consulta Personalizar una tabla.

112. Bundle formato 3; los bundles en formato 2 son rechazados

Sección titulada «112. Bundle formato 3; los bundles en formato 2 son rechazados»

A quién afecta: a cualquier despliegue de un bundle compilado — autoalojado con la imagen de runtime, o en Rebase Cloud.

Qué cambió: el esquema de un bundle pasa a ser entry.tables, junto a entry.resources, entry.storage y entry.hooks; bundleFormat es 3 y el contrato de runtime es 2. Un bundle de formato 1 o formato 2 contiene config/collections, que el runtime de 0.31 no puede interpretar, por lo que se niega a iniciar indicando el comando del codemod en el mensaje de error, en lugar de introspeccionar la base de datos y servir una API distinta.

Qué hacer: migra el código fuente, luego ejecuta rebase build y despliega. En Rebase Cloud, desplegar el repositorio migrado lo reconstruye automáticamente. Consulta Runtime y bundles.

En Rebase Cloud, un proyecto que permanezca en 0.30 sigue funcionando pero no puede desplegarse. La plataforma continúa sirviendo el bundle existente y sus actualizaciones de runtime se detienen allí (así lo indica la consola), pero solo acepta el formato 3: un despliegue desde una CLI 0.30 sube todo el bundle y luego es rechazado con BUNDLE_FORMAT_TOO_OLD. El camino a seguir consta de los mismos tres comandos en cualquier proyecto:

pnpm exec rebase upgrade --to latest
rebase migrate collections-to-tables
rebase cloud deploy

Una CLI posterior a 0.32.0 rechaza la operación antes, sin compilar ni subir nada: rebase build y rebase cloud deploy en un proyecto cuyas tablas aún estén en config/collections se detienen indicando el nombre del codemod, un --bundle-dir con un bundle en formato 2 es rechazado con el mensaje “Nothing was uploaded”, y rebase upgrade señala el codemod como siguiente paso en lugar de rebase build. (El propio rebase upgrade de 0.30 aún concluye diciendo “Run rebase build”; la compilación a la que apunta es la que se detendrá).

113. La versión del esquema se calcula a partir de las tablas (v2:)

Sección titulada «113. La versión del esquema se calcula a partir de las tablas (v2:)»

A quién afecta: a toda base de datos aprovisionada por un runtime anterior a 0.31, y a cualquier SDK generado.

Qué cambió: la versión del esquema genera un hash de los descriptores de tabla compilados y comienza con el prefijo v2:. Una base de datos marcada con v1: reporta el cambio de modelo una vez —el log de arranque y rebase doctor indican esto y cómo re-estamparla— y cada SDK generado se reporta como desactualizado una vez.

Qué hacer: realiza el aprovisionamiento una vez con el nuevo runtime: arranca el proceso propietario del esquema o ejecuta rebase db push. Con REBASE_REQUIRE_SCHEMA_MATCH=true, re-estampa la versión antes de reiniciar los demás procesos. Vuelve a generar el SDK.

114. Los códigos de error hacen referencia a tablas

Sección titulada «114. Los códigos de error hacen referencia a tablas»

A quién afecta: al código que evalúa condiciones basadas en un code de error.

Qué cambió:

Antes Ahora
NO_COLLECTIONS (404) NO_TABLES
COLLECTION_READ_ONLY (405) TABLE_READ_ONLY
UNKNOWN_COLLECTION (SDK) UNKNOWN_TABLE
INVALID_COLLECTION_PATH (SDK) INVALID_TABLE_PATH

Qué hacer: rebase migrate sdk-calls reescribe las cadenas literales. Consulta Errores.

115. El SDK apunta a una tabla: data.table(slug)

Sección titulada «115. El SDK apunta a una tabla: data.table(slug)»

A quién afecta: a todo cliente, función, cron, hook y script que referencie una tabla por su slug, o pase el diccionario generado.

Qué cambió:

Antes Ahora
data.collection(slug) data.table(slug)
createRebaseClient({ collections: collectionsDictionary }) createRebaseClient({ tables: tablesDictionary })
CollectionName, CollectionsDictionary generados TableName, TablesDictionary
lote { op, collection } (SDK y POST /api/data/_batch) { op, table }
CollectionClient, SDKCollectionClient, CollectionAccessor, CollectionTrashAccessor TableClient, SDKTableClient, TableAccessor, TableTrashAccessor
offline maxCachedRowsPerCollection, maxCachedQueriesPerCollection …PerTable
accessor reservado <name>Collection; collectionCollection <name>Table; la tabla collection es collection
const { data } = await client.data.collection("posts").find();
const { data } = await client.data.table("posts").find();

Los accessors tipados (client.data.posts) no sufren cambios.

Qué hacer: el codemod ejecuta rebase migrate sdk-calls sobre tu código —ejecútalo de forma aislada en un proyecto previamente migrado— y después ejecuta rebase generate-sdk. Las llamadas a .collection( cuyo receptor no sea el SDK se conservan intactas y se listan en el informe. Consulta Typed SDK.

116. Flags de la CLI: --schema-dir, no --collections

Sección titulada «116. Flags de la CLI: --schema-dir, no --collections»

A quién afecta: a scripts y pasos de CI que invocan la CLI con una ruta de esquema.

Qué cambió: --collections / -c son rechazadas en todos los comandos que leen el esquema, indicando el codemod en el mensaje (generate-sdk ignora un --collections-dir huérfano); --schema-dir especifica un directorio de esquema distinto de backend/schema. rebase schema introspect escribe archivos defineTable en backend/schema/ — la opción --output se ha eliminado. Ya no se lee REBASE_STRICT_COLLECTION_CONFIG: un esquema que no compile siempre impedirá el arranque.

Qué hacer: reemplaza las flags. Consulta CLI y Generación de esquemas.

117. El editor de esquemas edita backend/schema con TablePatch

Sección titulada «117. El editor de esquemas edita backend/schema con TablePatch»

A quién afecta: al código que consume las rutas del editor de esquemas o del esquema en vivo (live-schema), y a los despliegues que configuran variables de edición en vivo.

Qué cambió: /api/admin/schema-editor/collection/save, collection/delete, property/save y property/delete han desaparecido. El editor sirve GET /tables, POST /preview y POST /apply, y las rutas /plan y /apply de edición de esquemas en vivo ahora reciben { patches: TablePatch[] } en lugar de una colección o su parche. REBASE_LIVE_SCHEMA_COLLECTIONS_PATH es rechazada en el arranque: ahora es REBASE_LIVE_SCHEMA_PATH (por defecto backend/schema), y liveSchema.repository.collectionsPath es schemaPath. La presentación nunca constituye una edición de esquema: se guarda como preferencias de UI (/api/admin/ui-config). Cualquier edición cuyo archivo haya cambiado en el disco tras preparar el cambio (un guardado en el IDE, otro proceso) devuelve 409 SCHEMA_EDIT_STALE_FILE y no escribe nada; antes devolvía 400 SCHEMA_EDIT_REFUSED.

Qué hacer: renombra la variable; reescribe las llamadas a las rutas para que envíen ediciones TablePatch, y recarga si recibes SCHEMA_EDIT_STALE_FILE. Consulta Edición de esquemas en vivo.

A quién afecta: a las personalizaciones que hacían referencia a un componente de React mediante una ruta en formato string o una función perezosa () => import(…).

Qué cambió: las propiedades Field / Preview / Filter de un campo, Actions de colección, entityViews[].Builder, collectionViews[].Builder, formView.Builder y las anulaciones de componentes reciben directamente el componente. Se eliminan ComponentRef, ComponentLike, LazyComponentRef y isLazyComponentRef (@rebasepro/types), asComponentRef y asReactComponent (@rebasepro/cms-types) y resolveComponentRef / useResolvedComponent (@rebasepro/app). customizeTable rechaza un string o un thunk mostrando el mensaje “imported by value”.

Qué hacer: importa el componente en el archivo dentro de frontend/src/cms/ y pásalo directamente. Consulta Campos personalizados.

El codemod realiza esto con cada ruta en string y anota cada una, ya que un componente importado pasa por la verificación de tipos en su slot, algo que no ocurría con un string. Un Preview que declare customProps?: MyProps fallará en el tsc de tu frontend: el slot entrega customProps como unknown, dado que nada vincula las customProps de un campo con el componente que las lee. Declara customProps?: unknown y realiza el estrechamiento de tipos (type narrowing) dentro del componente.

119. Las preferencias del panel son preferencias de UI

Sección titulada «119. Las preferencias del panel son preferencias de UI»

A quién afecta: al código que implementa UserConfigurationPersistence.

Qué cambió: el ajuste de tamaño o reordenamiento que un usuario aplica sobre una tabla es un delta de UiTablePreferences: getTablePreferences / saveTablePreferences reemplazan a getCollectionConfig / onCollectionModified, y se elimina el tipo parcial de configuración de colecciones que recibía. El almacenamiento del navegador las guarda bajo table_preferences::<slug> e ignora lo guardado por paneles antiguos, por lo que el ancho de columnas y los modos de vista de cada usuario se restablecen por única vez. Desaparece userSelect en un campo: una columna .userId() actúa como selector de usuario.

El puente de Studio se adapta en consecuencia: StudioSchemaEditing.updateCollection pasa a ser applyTablePatches(slug, patches), y el editor de colecciones envía { patches } al editor de esquemas.

Qué hacer: adapta cualquier persistencia personalizada a los dos métodos nuevos, y cualquier StudioSchemaEditing personalizado a applyTablePatches.

A quién afecta: a proyectos que utilicen @rebasepro/server-mongo o declaren database(…, { engine: "mongodb" }).

Qué cambió: el paquete se ha eliminado, al igual que los tipos de colección de Mongo y el resto de su modelo. Postgres es el único motor de servidor: cualquier origen de transporte de servidor con otro motor impedirá el arranque, señalándolo de forma explícita.

Qué hacer: migra los datos a Postgres. No existe una ruta de migración interna dentro de Rebase.

121. Las colecciones de Firestore residen en el frontend

Sección titulada «121. Las colecciones de Firestore residen en el frontend»

A quién afecta: a proyectos híbridos con colecciones engine: "firestore".

Qué cambió: una colección de Firestore pasa a ser un origen de datos del CMS que el navegador lee directamente: defineFirestoreCollection desde @rebasepro/firebase, ubicado en frontend/src/cms/, y pasado a <RebaseCMS externalCollections>. Una referencia cruzada entre Firestore y una tabla Postgres se almacena con el id del objetivo, y una referencia de Firestore cuyo path coincida con el slug de Postgres ahora apunta a la tabla Postgres.

Qué hacer: el codemod genera los archivos defineFirestoreCollection. Apunta las referencias a colecciones de Firestore usando el slug de la colección. Consulta Firebase.

122. Las herramientas MCP se nombran para tablas

Sección titulada «122. Las herramientas MCP se nombran para tablas»

A quién afecta: a prompts, scripts y listas de permisos que hagan referencia a herramientas MCP.

Qué cambió: en /mcp remoto: list_collections, describe_collection, query_collection, show_collection, count_documents, aggregate_documents, get_document, create_document, update_document, delete_document pasan a ser list_tables, describe_table, query_table, show_table, count_rows, aggregate_rows, get_row, create_row, update_row, delete_row; el argumento collection es ahora table, y show_app / save_app reciben tables. En el servidor local: list_documents → query_table, get_document → get_row, create_document → create_row, update_document → update_row, delete_document → delete_row; rebase_schema_plan recibe patches; los recursos son rebase://tables/{name}. El payload de vistas de MCP Apps corresponde a la versión 3: descriptores de tabla redactados según el llamador, permisos por tabla y preferencias de UI de cada llamador bajo preferences (file, workspace, user; una clave de API no tiene capa de usuario), con bloques y semillas apuntando a table. La vista collection-table ha sido eliminada. list_tables no incluye title; describe_table añade primaryKey, relations, el rls del llamador, title y presentation.

Qué hacer: renombra los elementos. La vista y el servidor deben manejar la misma versión del payload: un conector alojado y los runtimes con los que interactúa se actualizan juntos, y las vistas MCP compiladas por el proyecto deben reconstruirse con los paquetes 0.31. Consulta Referencia de herramientas MCP y MCP remoto.

A quién afecta: a reglas que utilicen policy.existsIn o un tenant por membresía, y reglas que combinen access con otras cláusulas.

Qué cambió: policy.existsIn({ collection, where }) pasa a ser existsIn({ table, where }), y tenant.from.membership.collection pasa a ser membership.table; los nombres de las políticas no se alteran. Cuatro formas de regla conceden ahora permisos diferentes, dos de ellas de forma más amplia (ver tabla arriba): un { access: "authenticated" } simple, que antes no otorgaba nada, ahora admite a todo llamador autenticado, y las tablas intermedias (junctions) de dicha tabla adquieren sus políticas de escritura correspondientes. Las reglas que combinen cláusulas excluidas por SecurityRule, o contengan valores inválidos de access, mode, operation o roles, son rechazadas.

Qué hacer: el codemod renombra las claves, rechaza las reglas no válidas indicando archivo y línea, y lista las reglas que cambian de significado bajo “Review before deploying”. Para cada una: consérvala, define access: "registered" (llamadores autenticados con cuenta) o elimínala. Posteriormente revisa la salida de rebase db push --dry-run y rebase doctor --policies contra tu base de datos.

124. Studio lee las tablas desde el servidor

Sección titulada «124. Studio lee las tablas desde el servidor»

A quién afecta: a instancias de Studio conectadas a un backend anterior a 0.31, y scripts de la consola JS de Studio.

Qué cambió: todas las herramientas sensibles al esquema consultan GET /api/schema/tables; frente a un runtime que no disponga de esta ruta, mostrarán un aviso de actualización. La parte declarada en el editor de RLS corresponde a lo compilado por el servidor. Un script de consola JS recibe context.tables (anteriormente context.collections).

Qué hacer: actualiza el runtime a la par que el panel. Consulta Studio.

A quién afecta: a herramientas que consumen la salida de rls-check --format agent.

Qué cambió: remediation.rebase.securityRules pasa a ser remediation.rebase.rls, el extracto es un defineTable(…, { rls }), y la versión del formato del documento es 2. --json no cambia. Consulta rls-check.

Qué hacer: lee la nueva clave.

A quién afecta: a proyectos que utilizan el plugin de revisión.

Qué cambió: reviewSecurityRules(slug, review) pasa a ser reviewRls(slug, review), propagado en el rls de la tabla; findReviewConfigProblems y assertReviewConfig reciben descriptores de tabla.

Qué hacer: renombra la llamada y pasa services.tables() o compileTables(…).

A quién afecta: al código que invoca el generador directamente.

Qué cambió: generateTypedefs(tables) y generateSDK(tables, options) reciben TableDescriptor[] —lo devuelto por compileTables y servido por GET /api/schema/tables— en lugar de colecciones.

Qué hacer: compila tus definiciones previamente o utiliza rebase generate-sdk.

128. La habilidad de agente rebase-collections pasa a ser rebase-tables

Sección titulada «128. La habilidad de agente rebase-collections pasa a ser rebase-tables»

A quién afecta: a proyectos con habilidades de agente instaladas, y prompts o archivos de instrucciones que hagan referencia a dicha habilidad.

Qué cambió: la habilidad que instruye sobre el modelo de datos es ahora rebase-tables: creación de tablas, columnas, relaciones, rls, hooks y la capa CMS superior. rebase skills install elimina la copia obsoleta de rebase-collections, incluso de instalaciones previas a la existencia del manifiesto de skills, preservando cualquier directorio con ese nombre que hayas creado manualmente.

Qué hacer: ejecuta rebase skills install tras la actualización. Los pasos impresos por rebase migrate collections-to-tables también lo recordarán. Renombra la habilidad en cualquier archivo de instrucciones que la cite. Consulta Habilidades de agentes.

129. Se elimina useJsonCollectionsConfigController

Sección titulada «129. Se elimina useJsonCollectionsConfigController»

A quién afecta: a proyectos que almacenaban definiciones de colecciones en formato JSON mediante @rebasepro/cms.

Qué cambió: useJsonCollectionsConfigController ha desaparecido, junto con su tipo de opciones y la clase de almacenamiento JSON asociada. El esquema de una tabla reside en backend/schema, y su modo de visualización en el panel reside en las preferencias de UI: frontend/src/cms/ui-config.json en desarrollo, y la tabla rebase.ui_preferences en entornos desplegados.

Qué hacer: declara las tablas usando defineTable (rebase migrate collections-to-tables las genera a partir de las definiciones de colecciones) y proporciona el uiConfig del scaffold a <RebaseCMS>. Consulta Personalizar una tabla.

130. rebase build rechaza un frontend sin rebaseBackendGuard()

Sección titulada «130. rebase build rechaza un frontend sin rebaseBackendGuard()»

A quién afecta: a todo proyecto que incluya un frontend.

Qué cambió: el frontend solo puede importar desde backend/ elementos de tipo (import type). Importar un valor incluiría código de servidor —hooks y cualquier secreto que estos lean— en el bundle del navegador. rebaseBackendGuard() de @rebasepro/app/vitePlugin aborta vite build y vite dev si algún módulo del frontend resuelve referencias hacia backend/, indicando el importador, la importación y el archivo afectado, abarcando alias, rutas de tsconfig, resolución absoluta o por paquetes, globs, ?raw, reexportaciones e importaciones dinámicas. Tanto rebase build como la compilación de frontend ejecutada por rebase cloud deploy rechazan cualquier frontend cuya configuración de Vite no lo incluya; rebase dev emite una advertencia; rebase verify reporta cms-backend-guard-missing.

Qué hacer: el codemod lo incorpora en el archivo frontend/vite.config.ts del scaffold, e imprime las líneas requeridas para cualquier otra configuración:

import { rebaseBackendGuard } from "@rebasepro/app/vitePlugin";
export default defineConfig({
plugins: [react()],
plugins: [react(), rebaseBackendGuard()],
});

Posteriormente transforma cualquier importación de valor desde backend/ en import type.

131. Las filas transmitidas siguen el formato de su columna

Sección titulada «131. Las filas transmitidas siguen el formato de su columna»

A quién afecta: a clientes que lean claves foráneas o especifiquen relaciones, y escrituras que envíen columnas generadas u objetos JSON parciales.

Qué cambió: los valores atraviesan el codec de su columna al salir y las reglas de su columna al entrar.

  • Una columna de clave foránea bigint o numeric generada por una relación, que Postgres devuelve como texto, se entrega como número en REST, en el SDK y en el panel de administración. Las claves numéricas declaradas explícitamente ya lo hacían.

  • Los elementos de un array nativo se sirven bajo su tipo escalar correspondiente, en REST, el SDK, sockets y el driver:

    Columna 0.30 servía 0.31 sirve
    timestamptz[] ["2026-01-02 11:00:00+01"] ["2026-01-02T10:00:00.000Z"]
    numeric[] (un driver abierto sin el ajuste numérico de arranque: tests, scripts) ["1.50", "2.25"] [1.5, 2.25]
    bigint[] con un elemento nulo [1, 0, 3] [1, null, 3]
    date[], timestamptz[] o un array de enum con un elemento nulo ["2026-01-02", "NULL"] ["2026-01-02", null]

    date[], time[], text[], uuid[], boolean[], integer[] y double precision[] se siguen sirviendo igual. El almacenamiento permanece intacto: una fila leída y vuelta a guardar almacena el mismo array.

  • Toda relación nombrada en include, filtros u ordenamientos debe usar su nombre exacto. Se eliminan los reintentos automáticos con slug o notación snake_case.

  • Una columna generada es rechazada al intentar escribir en ella, y se omite en el esquema de entrada de OpenAPI.

  • Los campos requeridos dentro de un objeto JSON son validados de forma estricta; $inc y los elementos de array sobre una columna entera deben ser números enteros.

Qué hacer: lee las claves foráneas como números donde antes comparabas cadenas de texto, parsea los elementos de timestamptz[] según RFC 3339, gestiona elementos nulos de arrays como null, y escribe los nombres de relaciones exactamente como los declara la tabla (sus claves en relations). Deja de enviar columnas generadas en las escrituras.

A quién afecta: a consumidores de instantáneas del historial y a quienes implementen un DataDriver.

Qué cambió: las entradas del historial se sirven como lecturas: primero se valida el acceso a nivel de campo, seguido de afterRead (global, tabla, columna). Una columna enmascarada por un hook o por un .transform({ afterRead }) aparecerá enmascarada en cada snapshot; las columnas que el llamador no tenga permiso de leer son omitidas y se excluyen de changed_fields; se omiten las claves de columnas eliminadas, y un revert nunca escribirá en columnas que el llamador no pueda leer. Si un hook arroja un error sobre un snapshot antiguo, la petición fallará. Como 0.30 servía los valores almacenados en bruto (raw), los proyectos con historial y hooks de enmascaramiento deben actualizarse.

Una entrada contiene la fila en el mismo formato que GET /api/data/<table>/<id> sin include: valores simples, y un belongsTo representado mediante su clave foránea. Una entrada registrada por versiones anteriores bajo el modelo de vista del panel se sirve y revierte adaptada a dicho formato de fila: un envoltorio { "__type": "date", "value" } como su valor, una referencia { "__type": "relation" } de una relación propietaria como clave foránea bajo el nombre de la clave, y cualquier otra referencia como la clave de la fila relacionada. En 0.30 esas referencias se servían tal cual estaban escritas.

Un driver sirve el historial mediante DataDriver.serveStoredRows(path, rows), dentro de la transacción de solo lectura del llamador; las rutas de historial responden 501 si el driver no lo soporta, asegurando que el historial jamás se sirva sin enmascarar.

Qué hacer: no se requiere ninguna acción si usas el driver de Postgres incluido. Los drivers personalizados deben implementar serveStoredRows. Consulta Historial.

133. Las exportaciones de @rebasepro/server hacen referencia a tablas

Sección titulada «133. Las exportaciones de @rebasepro/server hacen referencia a tablas»

A quién afecta: a servidores construidos a partir de piezas de @rebasepro/server en lugar de usar initializeRebaseBackend / createRebaseBackend.

Qué cambió:

Antes Ahora
new RestApiGenerator(collections, …) new RestApiGenerator(tables, …) (RestTables)
mountOpenApiDocs({ collections }), createHistoryRoutes({ collections }) mountOpenApiDocs({ serverTables }), createHistoryRoutes({ tables })
versionProperty, buildCollection*Schema versionColumn, buildTable*Schema; helpers de validación, conflicto y ETag reciben un TableDescriptor
auth-collection-writes auth-table-writes: createUserThroughAuthTable, isAuthTable, prepareAuthTableUpdates, deletingAuthTableUsers
opción de adaptador de autenticación collectionAuthConfig authTableHooks (CompiledAuthHooks)
McpRoutesConfig.getCollections getTables()
assertUploadWithinPropertyLimits, readUploadPropertyContext assertUploadWithinColumnLimits, readUploadColumnContext (devuelve { table, column }); el detalle de rechazo indica column
provisionCollectionTables, provisionCollectionPolicies, collectionsStoredBy provisionTableSchema, provisionTablePolicies, tablesStoredBy
handGlobalCallbacksTo, warnOnAuthCollectionDataCallbacks handGlobalHooksTo, warnOnAuthTableDataHooks
SchemaEditingAdmin.planSchemaChange(collections, …) planSchemaChange(tables, …) con CompiledTable[]; EditedSchema.tables
buildCollectionFromTableMetadata, IntrospectedCollection, IntrospectedRelation eliminados: una tabla introspeccionada es un TableDescriptor
createUserThroughAuthCollection; NestedWriteHop.parentCollection / .targetCollection; ContractRoutesConfig.collectionRegistry createUserThroughAuthTable; .parent / .target (descriptores); eliminado
el cargador de colecciones: CollectionConfigError, ConfigProblem, applyCollectionDefaults, CollectionDefaults y el tipo de opciones del validador, accessModelFromCollections, loadBundleConfigExports, BundleConfigExports, unknownKeyPolicyFromEnv, UnknownKeyPolicy eliminados: compileSchema / loadBackendSchema cargan y validan backend/schema, y un SchemaDefinitionError especifica cada problema

Qué hacer: renombra las referencias. rebase migrate sdk-calls renombra assertUploadWithinPropertyLimits y las constantes de campos de subida (UPLOAD_COLLECTION_FIELD / UPLOAD_PROPERTY_FIELD → UPLOAD_TABLE_FIELD / UPLOAD_COLUMN_FIELD, conservando los mismos valores), y lista cualquier otra importación u opción de esta tabla como un paso manual numerado.

134. Las exportaciones de @rebasepro/server-postgres hacen referencia a tablas

Sección titulada «134. Las exportaciones de @rebasepro/server-postgres hacen referencia a tablas»

A quién afecta: al código que abre directamente el driver de Postgres, envuelve el adaptador o importa el planificador de esquemas.

Qué cambió:

Antes Ahora
la clase PostgresCollectionRegistry, getTable(name), registerTable PostgresTableRegistry, getPgTable, registerPgTable
openPostgresDriver(config, { collections }) openPostgresDriver(config, { tables }), obteniendo tables desde compileSchema; las llamadas al driver prescinden de la propiedad collection (sección 137)
adaptador / bootstrapper ensureCollectionSchema, ensureCollectionPolicies, readCollectionsSchemaVersion, stampCollectionsSchemaVersion ensureTableSchema, ensureTablePolicies, readTablesSchemaVersion, stampTablesSchemaVersion, recibiendo CompiledTable[]
serializePropertyToServer, parsePropertyFromServer serializeColumnToServer(value, column); parsePropertyFromServer se elimina — la lectura del driver devuelve directamente la fila REST (sección 136)
ensureCollectionTables, planCollectionSchemaEnsure, planCollectionPolicies, CollectionPolicyPlan, lockCollectionTables ensureTables, planTableSchemaEnsure, planTablePolicies, TablePolicyPlan, lockTables
CollectionIndexSpec, CollectionIndexConfigError, collectionIndexStatements TableIndexSpec, TableIndexConfigError, tableIndexStatements
checkCollectionsVsDatabase / …VsSchema / …VsSdk, columnKeysFromCollections, buildDrizzleRelationsFromCollections, schemaOfCollection, getTableIncludesFromCollections checkTablesVs…, columnKeysFromTables, buildDrizzleRelationsFromTables, schemaOfTable, getTableIncludesFromTables
SchemaDifference.collection, .property (y los campos de log en advertencias de desfase en el arranque) .slug, .key
createStampKeys, sharedRelationName, isAuthCollection, lowerCompiledTables, buildCollectionIndexPlan eliminados

El JSON que emite el planificador mantiene sus claves: SchemaReconcileColumn.collection y las variantes de SchemaChange se conservan idénticas.

Qué hacer: renombra las llamadas. Cualquier envoltorio que adapte el adapter a un BackendBootstrapper debe reenviar ensureTableSchema y ensureTablePolicies. Consulta Integrar el driver de Postgres.

135. @rebasepro/types y @rebasepro/common eliminan el modelo de colecciones de su raíz

Sección titulada «135. @rebasepro/types y @rebasepro/common eliminan el modelo de colecciones de su raíz»

A quién afecta: al código que importe tipos de colecciones o propiedades, helpers del panel de administración o utilidades de migración desde @rebasepro/types o @rebasepro/common —campos personalizados, vistas personalizadas, plugins, tests con fixtures de colecciones— y a drivers personalizados que implementen el registro.

Qué cambió: los paquetes núcleo ahora describen únicamente tablas. Todo lo relativo a cómo dibuja una colección el panel de administración se ubica en @rebasepro/cms-types:

  • Tipos trasladados desde @rebasepro/types: CollectionConfig, PostgresCollectionConfig, FirebaseCollectionConfig, AnyCollectionConfig, cada variante de …Property (StringProperty, NumberProperty, ArrayProperty, …) y Properties, CollectionCallbacks y sus props de hooks, los tipos de relación de 0.30 y sus variantes Resolved…, CollectionIndex, los colores de etiquetas (ColorScheme, ColorKey, …), FieldAccess, EnumValues.
  • Helpers trasladados desde @rebasepro/common: los helpers de políticas basados en colecciones (policyToPostgres, compileRulePolicies, getEffectiveSecurityRules, getGeneratedPolicyNames, …), CollectionRegistry, resolveCollectionRelations, resolveRelation, getTableName, findRelation, rowToViewModel, resolvePrimaryKeys, la vista de acceso a campos de una propiedad (effectiveAccess, canReadField, canWriteField), evaluateCondition, canEditEntity, resolveProperty, getDefaultValuesFor, getSubcollections, getCopyValues, enumToObjectEntries. Para compilar una regla a partir de una expresión simple, usa compilePolicyExpression(expr) de @rebasepro/common.
  • composeCallbacks compone los callbacks de una colección para el panel y se trasladó a @rebasepro/cms-types; @rebasepro/server ya no lo reexporta. El código de backend compone los hooks de una tabla con composeTableHooks desde @rebasepro/common, y el codemod señala cualquier importación de composeCallbacks en el backend como un paso manual.
  • defineCollection se elimina de @rebasepro/common y @rebasepro/cms-types: define la tabla con defineTable en backend/schema y customízala con customizeTable en frontend/src/cms; una colección de Firestore se declara con defineFirestoreCollection desde @rebasepro/firebase.
  • El accessor del panel de administración y sus tipos: Entity, EntityValues, TableAccessor, TableTrashAccessor, FindResponse, QueryBuilderInterface, RebaseData y AuthState salieron de @rebasepro/types; buildRebaseData, wrapAsEntityData, buildRoutedRebaseData, EntityDataOptions, QueryBuilder, RelationRef y createRelationRef salieron de @rebasepro/common. Todos se importan ahora desde @rebasepro/cms-types. La capa de datos propia del SDK —buildSdkData, createDriverTableRows, buildRoutedSdkData, en @rebasepro/common— sirve filas directamente y mantiene su respuesta previa.
  • EntityDataOptions.resolveCollection se sustituye por primaryKeysOf, viewModelOf, storedValuesOf y viewModelSourceOf; collectionEntityDataOptions(resolveCollection, { resolveDataPath, resolveAccessor }) desde @rebasepro/cms-types los construye.
  • La utilidad de migración (collectionsToTableDefs, collectionToTableDef, LiftNote, LiftResult, LiftOptions) pasó a @rebasepro/common/migrate, junto a una copia congelada del modelo de colecciones de 0.30 (tipos Legacy…) y defineLegacyCollection.
  • Otros elementos eliminados de la raíz de los paquetes núcleo, señalados por el codemod como pasos manuales: la API de parches de colecciones de @rebasepro/types (CollectionPatch, CollectionPatchOp, applyCollectionPatch, collectionPatchProblems, isCollectionPatch, nestCollectionPatchPaths → TablePatch), sus helpers de JSON de colecciones (diffCollections, diffJsonValues, toCollectionJson, RUNTIME_ONLY_COLLECTION_KEYS, runtimeOnlyKeyIn), la funcionalidad heredada de Mongo DocumentAdmin, isDocumentAdmin y supportsDocumentAdmin, y RebaseProjectContract.collectionSlugs / .collections / .generatedAt (/api/meta/contract sirve ahora tables); en @rebasepro/common, buildTenantSecurityRule → tenantSecurityRule, defaultPoliciesDisabled → tableDefaultPoliciesDisabled, restoresSoftDeletedRow → isSoftDeleteRestore, softDeleteFieldOf → softDeleteColumn, getJunctionConfigForRelation → resolveTableJunctions, y isRelationRequired, relationDeclaringProperty, requireCallbackCollection sin reemplazo directo (debe consultarse el TableDescriptor).
  • El registro de un driver pasa a ser TableRegistryInterface (anteriormente CollectionRegistryInterface): setGlobalHooks? y setTableHooks? sustituyen a getGlobalCallbacks / setGlobalCallbacks?. Se eliminan globalHooksAsCallbacks, resolveDriftCheckName y PENDING_TABLE_FEATURES.

Qué hacer: rebase migrate sdk-calls (parte de collections-to-tables) reubica cada importación listada a su nuevo paquete —fusionándola con importaciones previas de ese paquete en el mismo archivo, preservando import type, type en línea y alias as— y añade dicho paquete a las dependencias del workspace correspondiente; ejecuta pnpm install al finalizar. Las importaciones de elementos retirados, imports de espacio de nombres (import * as), export *, importaciones dinámicas import() o llamadas a require() con nombres trasladados se listarán como pasos manuales numerados. Los tests que utilicen literales de colecciones como fixtures deben tiparse con los tipos Legacy… y transformarse con @rebasepro/common/migrate.

Cada elemento trasladado a otro paquete en 0.31, o eliminado, se encuentra documentado en Importaciones trasladadas en 0.31, junto a las instrucciones para sustituir los suprimidos. Dicha lista proviene de la misma tabla que consulta el codemod, reflejando exactamente lo que reescribe rebase migrate sdk-calls.

136. El driver de Postgres y las lecturas puntuales del socket devuelven la fila de REST

Sección titulada «136. El driver de Postgres y las lecturas puntuales del socket devuelven la fila de REST»

A quién afecta: a funciones o plugins que lean vía requireDriver(c) / getDriver(c), código que emita frames FETCH_COLLECTION / FETCH_ONE por socket, y código que consuma objetos { __type } en una respuesta.

Qué cambió: ahora existe una única estructura de lectura. fetchCollection y fetchOne en el driver de Postgres —usados por requireDriver(c) en funciones, plugins, frames puntuales de sockets, MCP y el simulador de RLS— devuelven la misma estructura que GET /api/data/<table>:

Valor Lectura del driver en 0.30 0.31
una marca de tiempo { "__type": "date", "value": … } una cadena RFC 3339
un belongsTo { "__type": "relation", "id", "path" } bajo el nombre de la relación la clave foránea bajo su propia clave (authorId)
una fila relacionada todas las relaciones cargadas por fetchOne únicamente las relaciones indicadas en include, bajo la fila propia del objetivo
un vector, un bytea { "__type": "Vector" }, un data URL en el formato habitual servido por REST

FetchOneProps admite include (ListenOneTarget ha sido eliminado: utiliza FetchOneProps). Tanto rebase.data, context.data como el SDK ya devolvían este formato y permanecen sin cambios.

@rebasepro/client interpreta los cuerpos de REST y frames de socket como JSON plano: los valores con la clave __type ya no se transforman automáticamente en Date, EntityReference, EntityRelation, GeoPoint o Vector, y un documento JSON que contenga __type se devuelve tal como está guardado.

Qué hacer: lee la fila de datos planos: parsea las fechas desde sus cadenas de texto, accede a las claves foráneas desde su propia clave, y especifica include para cada relación que requieras:

const article = await requireDriver(c).fetchOne({ path: "articles", id });
const authorId = article?.author.id; // a { __type: "relation" } ref
const article = await requireDriver(c).fetchOne({ path: "articles", id, include: ["author"] });
const authorId = article?.authorId;

137. Las interfaces del driver y del backend utilizan tablas, no colecciones

Sección titulada «137. Las interfaces del driver y del backend utilizan tablas, no colecciones»

A quién afecta: a implementaciones de DataDriver personalizadas, adaptadores de base de datos o backends armados a partir de componentes de @rebasepro/server.

Qué cambió:

Antes Ahora
la propiedad collection en llamadas de DataDriver (fetch, save, delete, count, search, listen) eliminada: el driver identifica la tabla a servir mediante path
checkUniqueField(path, name, value, id, collection) checkUniqueField(path, name, value, id?)
scanStoredRows({ path, collection, pageSize }) scanStoredRows({ path, pageSize })
DataDriver.initTextSearch eliminada
DatabaseAdapterInitConfig.collections, .collectionRegistry eliminadas: el adaptador recibe CompiledTable[]
BackendServices.collections() services.tables()
serializeCollections, deserializeCollections, isSerializedCollectionRef, SerializedCollectionRef eliminados: los descriptores se sirven en GET /api/schema/tables
AuthAdapter.prepareUserCreation(values, collectionAuth, options?), describeUserCreationContract(collectionAuth) prepareUserCreation(values, options?), describeUserCreationContract()
initializeDriver devolviendo { driver, collectionRegistry, … }; BackendInstance.collectionRegistry { driver, tableRegistry, … }; BackendInstance.tableRegistry
PolicyEvalContext.entity (un Entity) PolicyEvalContext.row (los valores de la fila)
wrapAsSdkData(…) buildSdkData(driver); múltiples fuentes de datos: buildRoutedSdkData
FindResponse desde @rebasepro/client FindResult
ListenCollectionRequest, ListenEntityRequest desde @rebasepro/server ListenCollectionProps, ListenOneProps

Qué hacer: descarta esos argumentos y consulta las tablas mediante path. El codemod indicará implements DataDriver como un paso manual. Consulta Integrar el driver de Postgres.

138. El backend solo acepta los valores documentados por la API REST

Sección titulada «138. El backend solo acepta los valores documentados por la API REST»

A quién afecta: a clientes que envíen relaciones uno a uno como un objeto o vectores como { value }, código que aplique filtros sobre una relación pasando un objeto, código que importe las clases de valores del panel de administración, y aplicaciones offline con escrituras en cola generadas en 0.30.

Qué cambió: las operaciones de escritura adoptan la misma estructura que devuelven las lecturas —un formato único para REST, sockets, MCP y el SDK en proceso:

Valor Aceptado Rechazado a partir de ahora
una relación a uno (belongsTo, hasOne, un via hacia uno) la clave de la fila relacionada, o null ("" cuenta como null), bajo el nombre de la relación o el de la clave foránea un objeto como { "id": 5 }: 400 VALIDATION_INVALID_VALUE, “‘posts.author’ links one ‘authors’ row: write that row’s key (a string or a number), or null to unlink — not an object.”
una relación a muchos (hasMany, manyToMany, un via hacia muchos con permisos de escritura) una lista de claves, o de { id, _pivot? } — (las demás claves en el objeto se descartan, como antes)
un vector una lista de números una instancia de Vector o { "value": [...] }: 400, “‘embedding’ expects a vector as a list of numbers”
fecha u hora texto ISO (Date en proceso) —
un geopoint { latitude, longitude } —
un bytea una URL en formato data:application/octet-stream;base64, (Buffer / Uint8Array en proceso) —
un filtro sobre una relación la clave los objetos ya no se desglosan: se comparan literalmente tal cual se envían

0.30 permitía escribir relaciones uno a uno mediante un objeto y extraía silenciosamente su id; este comportamiento nunca fue documentado y correspondía al view model del panel de administración. El panel de administración ahora convierte su view model a valores de red en el navegador antes de cada escritura y filtro.

Las clases de valores del panel se trasladaron junto al resto de su modelo de vistas: EntityReference, EntityRelation, GeoPoint, Vector y EntityReferenceProps se importan desde @rebasepro/cms-types (salieron de @rebasepro/types), al igual que normalizeToEntityRelation (salió de @rebasepro/common); withRelationReferencesOnly ha sido suprimido. El historial almacena la fila tal como la entrega una lectura; las entradas previas se sirven y revierten bajo valores planos (sección 132).

La cola offline de @rebasepro/client almacena valores listos para transmisión. Una escritura encolada offline por el SDK de 0.30 se convertirá automáticamente al leerse y reproducirse: nada de lo encolado antes de la actualización se perderá.

Qué hacer: envía directamente la clave: { "author": 5 }, en lugar de { "author": { "id": 5 } }; envía vectores como listas de números y filtra las relaciones por su clave. rebase migrate sdk-calls actualiza las importaciones de clases de valores (la lista). Consulta Escrituras.

139. /api/docs se sirve a la audiencia del endpoint de esquema

Sección titulada «139. /api/docs se sirve a la audiencia del endpoint de esquema»

A quién afecta: a usuarios o herramientas que consuman /api/docs o abran /api/swagger —Swagger UI, generadores de clientes de API, pasos de CI.

Qué cambió: sin definir enableSwagger (sin configurar REBASE_ENABLE_SWAGGER), en cualquier entorno, el documento OpenAPI se ofrece exactamente a los mismos llamadores a los que GET /api/schema/tables describe tablas, aplicando los mismos rechazos —401 si el llamador es anónimo salvo que se active schemaTables.public, 403 si las credenciales carecen del alcance para esquema o datos— y cada llamador recibe el documento correspondiente a las tablas, columnas y relaciones a las que dicho endpoint le da acceso (un administrador lo recibe completo). No se incluye Swagger UI. Si el servidor no tiene configurada autenticación, responderá 404 DOCS_UNAVAILABLE. En desarrollo, 0.30 exponía todo el documento, con todas las tablas y columnas no privadas, a llamadores anónimos, y lo restringía solo a administradores en producción.

enableSwagger / REBASE_ENABLE_SWAGGER /api/docs /api/swagger
sin definir (por defecto) a cada llamador al que el endpoint de esquema le describe tablas: sus tablas correspondientes no se sirve
true el documento completo, accesible para todos servido fuera de producción
false el documento completo, restringido a administradores no se sirve

Qué hacer: realiza las llamadas a /api/docs con una sesión autenticada. Para exponer la totalidad del documento como hacía 0.30 en desarrollo, define REBASE_ENABLE_SWAGGER=true (o enableSwagger: true). Consulta Endpoints.

140. Una columna pivot many-to-many no puede declarar .transform()

Sección titulada «140. Una columna pivot many-to-many no puede declarar .transform()»

A quién afecta: a definiciones rel.manyToMany(…, { pivot: { … } }) cuya columna de pivote incluya un .transform().

Qué cambió: el compilador lo rechaza (“the pivot column “x” declares .transform() …“). La transformación de una columna pivote nunca se ejecutaba en ningún flujo, lo que causaba que valores que pretendías enmascarar se sirvieran tal como estaban almacenados.

Qué hacer: elimina el .transform() y enmascara _pivot en el hooks.afterRead de la tabla destino. Consulta Relaciones.

141. Un enlace es exactamente tan legible y escribible como su columna de clave

Sección titulada «141. Un enlace es exactamente tan legible y escribible como su columna de clave»

A quién afecta: a clientes que escriban un belongsTo a través del nombre de la relación, lean o filtren relaciones cuya columna de clave esté restringida, o dependan de strictWrites: false.

Qué cambió: toda restricción sobre una columna de clave aplica a cualquiera de las formas sintácticas utilizadas para leerla o escribirla.

  • Escribir un enlace mediante el nombre de su relación ({ "reviewer": 7 }) queda sujeto a todas las reglas de la columna clave que asigna —.readOnly(), .private(), access.write, marcas temporales de creación, columna de tenant, inmutabilidad de clave— en REST, bulk, _batch, sockets y MCP. Enviar el enlace bajo ambos nombres ({ "reviewer": 7, "reviewerId": 8 }) con valores distintos genera un error 400 VALIDATION_INVALID_VALUE. Intentar mover una fila a otro tenant a través de su enlace devuelve 400 TENANT_IMMUTABLE (anteriormente daba un error 500).
  • Una relación solo es legible cuando el llamador tiene permiso para leer todas las columnas involucradas en su join, a lo largo de cada tabla intermedia: la clave del belongsTo, la clave foránea en la tabla destino para un hasMany / hasOne, y cada columna donde se unen los pasos de un via. Si una falla, se excluye de include y _count, y cualquier filtro, ordenamiento o ruta relacional que la atraviese devolverá FIELD_NOT_READABLE (o relación desconocida si la columna es .private()). Una escritura en un via hacia uno que requiera copiar una columna no legible por el llamador será rechazada con FIELD_NOT_READABLE. Los casos inversos y con via ya estaban desprotegidos en 0.30.x.
  • Un enlace cuya columna clave sea inaccesible para lectura se omite de include, y cualquier filtro, ordenación, entrada en fields o ruta de relación a través de él responderá con FIELD_NOT_READABLE; un enlace asociado a una clave .private() se comportará como una relación inexistente. GET /api/schema/tables, OpenAPI y el describe_table de MCP describen de forma conjunta el enlace y su clave, de modo que si el enlace no es accesible, la columna clave también se oculta en esas definiciones.
  • strictWrites: false solo determina una cosa: si una clave no declarada se traslada al driver (escribiéndose si la columna existe en la base de datos, o dando 400 VALIDATION_UNKNOWN_FIELDS si no). Jamás flexibiliza las restricciones de una columna declarada, marcas temporales, tenant, clave primaria, destino de relación o regla sobre un _pivot.

Qué hacer: escribe un enlace usando un único nombre, o usando ambos pero con idéntico valor; lee enlaces restringidos empleando un rol autorizado para leer su clave. Consulta Acceso a campos.