Upgrading
Mise à niveau de 0.30 à 0.31
Mise à niveau 0.30 → 0.31
Section intitulée « Mise à niveau 0.30 → 0.31 »La version 0.31 rend le backend axé en priorité sur Postgres (Postgres-first). Les tables que vous déclarez avec defineTable dans backend/schema/ sont la seule chose que le backend connaît de vos données ; ce que le panneau d’administration affiche par-dessus réside dans le frontend. Presque chaque point ci-dessous découle de cette séparation, et la quasi-totalité est prise en charge pour vous par une seule commande.
La liste de contrôle, par projet
Section intitulée « La liste de contrôle, par projet »-
Mettez d’abord à niveau tous les packages
@rebasepro, dans chaque package de l’espace de travail (workspace), afin que les types lus par le codemod soient ceux de la version 0.31 :pnpm -r up "@rebasepro/*@0.31.0", puispnpm install. Un projet utilisant une version antérieure à 0.30 doit d’abord appliquer les modifications de code des guides intermédiaires (Mise à niveau) et respecter les versions minimales de la chaîne d’outils de la 0.31 — Node 22.22, TypeScript 6, React 19.2.7, React Router 8, Vite 8 (la liste) : le codemod charge un dossierconfig/de version 0.20–0.29 et sa vérification SQL réussit, mais cette vérification compare le compilateur 0.31 avec lui-même — seule l’étape 7, exécutée sur votre base de données, prouve que le DDL généré correspond bien à ce qui se trouve dans votre base de données. -
Commitez, puis exécutez le codemod à blanc (dry run) :
rebase migrate collections-to-tables --dry-run. Il affiche les fichiers qu’il écrirait, ce qu’il refuse (avec fichier et ligne), les remarques et les étapes manuelles, sans rien écrire. Corrigez d’abord ce qu’il refuse dansconfig/. -
Exécutez-le pour de bon :
rebase migrate collections-to-tables. Il écritbackend/schema/,frontend/src/cms/(avecui-config.json), les modulesbackend/et les fichiers du projet, ajouterebaseBackendGuard()au fichiervite.config.tsdu scaffold, réécrit vos appels SDK, déplace les imports des éléments que la version 0.31 a déplacés vers un autre package (section 135), et s’assure que le SQL généré est strictement identique au niveau des octets — ou restaure chaque fichier dans son état initial. Voir la section 108. -
Lisez la dernière section de sa sortie, « Review before deploying: these rules change meaning », et prenez une décision pour chaque règle répertoriée (ci-dessous).
-
Effectuez les étapes manuelles qu’il affiche, dans l’ordre. Chacune indique son fichier, et la plupart fournissent l’extrait de code à écrire : le montage de
<RebaseCMS>avectableCustomizationsetuiConfiglorsque votreApp.tsxn’est pas celui du scaffold (ou lorsque le panneau est monté dans un autre module, que l’étape indique),rebaseBackendGuard()lorsque votrevite.config.tsn’est pas celui d’origine et dans toutes les autres applications statiques derebase.json(section 130), les hooks globaux, l’import d’un nom supprimé par la version 0.31 (section 135), etrebase skills installlorsque le projet contient des compétences d’agent (section 128). Exécutezpnpm installlorsque la sortie indique « Dependencies added ». Lisez ensuite deux listes dans la section SDK de la sortie :- « Rewritten by name — review » : les appels
.collection(sur un récepteur sans type (any), réécrits parce que le récepteur est nommédataAsAdmin, ou est.dataavec un nom de table littéral ; le membrecollectiond’un type contenu dans un emplacementdata/dataAsAdmin; et les doublures de test. Vérifiez que chacun correspond bien au SDK. - « Left unchanged — check each » : les appels
.collection(pour lesquels le codemod n’a pas pu prouver qu’il s’agit du SDK, comme un appel via un type déclaré par votre projet lui-même. Un appel laissé ici qui est bien le SDK échouera à l’exécution sous 0.31 : renommez-le manuellement en.table(. Le code testant sicollectionexiste (typeof data.collection === "function") constitue une étape manuelle : sous 0.31, il prendra silencieusement l’autre branche.
Un fichier commité en tant que résultat de build (un fichier
.jspackagé ou minifié) n’est jamais modifié : il est listé afin que vous le reconstruisiez après la migration, et que vous remplaciez une copie vendorisée du client par la version 0.31. Les étapes répétées d’un même type ne sont affichées qu’une seule fois, en listant chaque fichier et ligne concernés ;--jsonconserve chaque étape séparément. Lisez ensuite Ce que les projets ont modifié manuellement : les modifications que de réels projets ont encore dû apporter après ces étapes. - « Rewritten by name — review » : les appels
-
Exécutez la ligne
git rmaffichée par le codemod une fois le diff examiné et la commanderebase migrate collections-to-tables --checkvalidée :git rm -r config/collections …et la configuration déplacée versbackend/, ougit rm -r configlorsqu’il ne reste plus rien de personnalisé à cet endroit (section 109). Les trois étapes suivantes en ont besoin :generate-sdk,db push,doctoretverifyrefusent un projet contenant encoreconfig/collections. -
rebase generate-sdk— les noms du module généré ont changé (section 115). -
Sur votre base de données, exécutez
rebase db push --dry-runet attendez-vous au message « No changes: the database already matches these tables. », puisrebase doctor --policiesen vous attendant à aucune dérive de stratégie. La vérification SQL du codemod prouve la fidélité de la conversion ; ces deux commandes le prouvent face à la vraie base de données, et toute différence de stratégie listée par l’une ou l’autre représente un changement dans les droits d’accès. -
rebase verify— lit désormais égalementfrontend/src/cms: une personnalisation ciblant une table ou un champ inexistant, une colonne obligatoire absente du formulaire, unrebaseBackendGuard()manquant, un fichierui-config.jsonnon transmis à<RebaseCMS>. -
Reconstruisez et déployez. Un bundle construit avant la version 0.31 ne démarrera pas sur un runtime 0.31 (section 112). Le premier démarrage met à jour l’empreinte de la version du schéma de la base de données une fois pour toutes (section 113).
Exécutez rebase migrate collections-to-tables --check dans votre CI jusqu’à ce que config/ ait disparu : cela vérifie que les tables migrées génèrent toujours le même SQL que les collections dont elles sont issues, et renvoie un code de sortie 1 tant qu’une règle listée sous « Review before deploying » n’a pas été confirmée — passez --accept-rule-changes une fois que vous les avez examinées.
À examiner avant le déploiement : ces règles changent de sens
Section intitulée « À examiner avant le déploiement : ces règles changent de sens »Le codemod conserve chaque règle de sécurité telle qu’elle est écrite, et chacune garde son nom de stratégie. Cependant, le compilateur 0.30 ne lisait que la première clause parmi condition, using, access: "public" et ownerField, et ne connaissait aucune autre valeur pour access. Par conséquent, quatre formes de règles accordent désormais des droits différents. Deux d’entre elles élargissent les accès :
| La règle | 0.30 accordait | 0.31 accorde | |
|---|---|---|---|
un simple access: "authenticated" (sans roles) |
rien | tous les appelants connectés, invités inclus | élargit |
access + check, sans condition, sur select / update / delete / all |
aucune ligne existante | chaque ligne existante, aux appelants access |
élargit |
access: "authenticated" + condition |
quiconque correspond à condition |
uniquement les appelants connectés qui y correspondent | restreint |
access: "authenticated" + check, sur insert |
quiconque insère une ligne correspondante | uniquement les appelants connectés | restreint |
Le cas le plus courant est le premier. Indiquez access: "registered" pour n’admettre que les appelants disposant d’un compte (pas les invités anonymes), ou supprimez la règle pour continuer à ne rien accorder. access avec roles, ainsi qu’une condition sous forme d’objet simple, conservent leur signification précédente et ne sont pas listés.
Le codemod refuse également les règles que le compilateur 0.31 refuse : celles combinant des clauses exclues par le type SecurityRule (access aux côtés de ownerField, using ou withCheck ; ownerField aux côtés de using, withCheck, condition ou check ; condition ou check aux côtés de using ou withCheck), ainsi que celles ayant une valeur invalide pour access, mode, operation(s) ou roles — une faute de frappe telle que "restrictive" était auparavant compilée comme permissive. Voir Règles de sécurité.
Autres changements de comportement
Section intitulée « Autres changements de comportement »- Ce que
GET /api/schema/tablesrenvoie à un utilisateur. Les administrateurs et les détenteurs deschema:readobtiennent toutes les tables. Tout autre utilisateur connecté, y compris les invités, n’obtient que les tables accessibles à ses rôles, avec uniquement les règles qui peuvent s’appliquer à lui ; les relations vers d’autres tables sont omises et les indicateurs de hooks sont masqués. Un frontend qui lisait la description d’une autre table en tant qu’utilisateur standard reçoit moins d’informations ; l’optionschemaTables: { persons: "all" }dans les options du backend permet de restaurer la description complète. Voir Endpoints. - Les noms de relation sont exacts, et les clés étrangères de type grand entier (big-integer) sont des nombres (section 131).
- L’historique est servi masqué (section 132).
- Les noms des outils MCP et le payload des vues changent de concert pour le connecteur hébergé et les environnements d’exécution qu’il atteint (section 122).
- Restrictions intentionnelles. Les horodatages d’audit (colonnes
.onCreateNow()/.onUpdateNow()) sont masqués par défaut dans les colonnes de liste du panneau : une liste migrée qui affichaitcreated_atperd cette colonne tant que vous n’ajoutez pasfields: { created_at: { hidden: false } }dans soncustomizeTable. Le codemod refuse, avec indication du motif, les tableaux JSON de tuples, un typevector/binary/referenceà l’intérieur d’une map,databaseIdsur une collection Postgres,isId: "cuid", une relationisIdunique etdisableDefaultPolicies: truesans aucune règle. Une relation sur une seule colonne vers une table avec clé composite est refusée (déclarez-la avecrel.via()). Les tags OpenAPI proviennent du slug, et non du nom d’affichage.rebase schema introspectomet les tables sans clé primaire et en indique la raison (un serveur qui introspecte la base de données continue de la servir). Une vue standard déclarantrolesprovoque une erreur de compilation ; le codemod la supprime en émettant une note. - Ce que les projets réels ont encore modifié manuellement — versions minimales de la chaîne d’outils,
({ entity })dans le code d’administration, inclusions d’une relation renommée, objets de collection modifiés à l’exécution, appels SDK sur des récepteurs non typés : Ce que les projets ont modifié manuellement. - Restauration vers un autre cluster. L’empreinte des stratégies d’administration par défaut hache les OID de rôles ; ainsi, après un dump ou une restauration à un instant précis (PITR) sur un cluster différent, le premier
db pushou démarrage recrée ces stratégies une seule fois, avec les mêmes noms et le même SQL.
Évolution du vocabulaire
Section intitulée « Évolution du vocabulaire »| Avant | Maintenant | Où « collection » subsiste |
|---|---|---|
une collection dans config/collections/ |
une table dans backend/schema/ (defineTable) |
— |
properties |
columns (col.*) et relations (rel.*) |
— |
securityRules, defaultSecurityRules |
rls (obligatoire), defaultRls |
— |
callbacks, Property.callbacks |
hooks, le .transform() d’une colonne |
— |
le bloc admin |
customizeTable dans frontend/src/cms/ |
— |
data.collection(slug) |
data.table(slug) |
— |
| ce que le panneau d’administration affiche | une collection : une table telle que le panneau l’affiche, ou une collection Firestore | le CMS : CollectionPanel, le Collection Editor, externalCollections |
108. Les tables dans backend/schema remplacent config/collections — exécutez d’abord le codemod
Section intitulée « 108. Les tables dans backend/schema remplacent config/collections — exécutez d’abord le codemod »Qui cela concerne : tout projet disposant d’un répertoire config/collections/.
Ce qui a changé : le backend lit uniquement backend/schema/index.ts ainsi que les résultats defineTable, defineAuthTable et defineView qu’il exporte. Les fichiers defineCollection ne sont plus lus par aucun composant : le runtime, chaque commande de la CLI et la validation de rebase.json refusent un projet qui possède encore config/collections, en mentionnant la commande ci-dessous. rls est obligatoire sur chaque table — une liste de règles, "admin-only", ou "inherit" pour le defaultRls exporté par l’index — et disableDefaultPolicies devient defaultPolicies: false.
Ce qu’il faut faire :
rebase migrate collections-to-tables # or --dry-run firstLa commande génère une table par collection, chaque colonne physique étant explicite à sa position d’origine (la colonne clé d’un belongsTo est donc explicitement écrite), l’index avec defaultRls issu de defaultSecurityRules, un customizeTable pour chaque collection dont la présentation n’était pas celle par défaut, et des fichiers defineFirestoreCollection pour les collections Firestore. Les callbacks d’une collection deviennent les hooks de sa table et les .transform() de ses colonnes ; les callbacks globaux exportés par config/index.ts nécessitent une étape manuelle (section 109). Ensuite, la commande relit le résultat à travers le nouveau pipeline : DDL, stratégies, recherche, vecteurs, déclencheurs, vues et schéma Drizzle doivent être strictement identiques au niveau des octets à ce que les collections généraient, sans quoi tous les fichiers sont restaurés et l’exécution s’arrête avec le code d’erreur 1 en affichant le diff.
Elle prend également en charge ce qui nécessitait auparavant des interventions manuelles :
- Les callbacks construits par un helper (
callbacks: softDeleteCallbacks(...), ou un objet de callbacks importé) deviennenthooks:avec la même expression, et les fonctions du helper sont converties en propriétés de hooks de table là où elles sont écrites (le codemod suit les imports relatifs, lesconst, les lectures de propriétés et un simplereturn). Lorsqu’il ne peut pas suivre le helper, une étape indique les hooks à vérifier. - Une fonction
storagePathmigre en deux moitiés : la fonction devient lestorage.pathde la personnalisation afin que le panneau continue de choisir l’emplacement de téléversement, et le modèlepathde la colonne prend la forme des clés qu’il retourne — le texte statique de son template literal où chaque${…}devient{path}(`${owner}/cv`→{path}/cv). Le serveur applique désormaismaxBytesetacceptde la colonne à chaque téléversement dont la clé correspond à ce modèle, et non plus seulement à ceux nommant expressément la colonne ; les limites sont donc plus strictes qu’en 0.30. Une fonction dont le résultat ne comporte aucun texte statique est refusée : ajoutez-en un d’abord. - Un
policy.existsIn({ collection })de la 0.30 conserve sa table, etauth: { collection: usersCollection }dans une entrée de backend personnalisée est supprimé (ledefineAuthTableconstitue la table d’authentification). Une option de démarragecollectionsdevientschemaDir. - Un générateur de
dynamicPropsrenvoie des personnalisations de champ avec des clés aplaties en 0.31 ({ readOnly: true }, et non plus{ admin: { readOnly: true } }). Le codemod réécrit les builders dont les retours sont des littéraux d’objets, en ligne ou dans un module partagé, et liste les autres. - La présentation propagée (spread) depuis un objet partagé unique est intégrée dans la personnalisation (
….dynamicProps) ; une présentation calculée par une fonction d’encapsulation (wrapper) constitue une étape à vérifier, et non un refus du projet. Le chemin d’un composant est résolu par rapport au module qui l’a écrit, et une valeur calculée au chargement deconfig/(new Date(),Date.now(), une lecture d’environnement) est conservée sous forme d’expression, sans jamais être figée à la valeur de l’exécution. - Les collections Firestore construites par une fonction (un
getAllFirestoreCollections()injecté par l’application dans le panneau) sont converties une par une endefineFirestoreCollectiondès lors que le fichier d’une collection contient son littéral ; une étape par fonction génératrice liste les autres ainsi que la structure à écrire, et une autre indique les références rédigées en dehors d’un littéral converti, qui mentionneraient encorepath. - Les imports de
config/via un alias de chemin (une entréepathsde tsconfig, unresolve.aliasde Vite) sont réécrits ou listés de la même façon que les chemins relatifs, et une fonctionstorageAuthorizeréexportée parconfig/index.tsest déplacée versbackend/storage.ts. - Une relation renommée en
<key>Relationconserve son libellé, sa colonne de liste et son titre : la personnalisation utilise la nouvelle clé. Le code qui l’inclut ne suit pas automatiquement (ce qu’il faut modifier).
Ce qui ne peut pas être transposé exactement est refusé avec indication du fichier et de la ligne, et rien n’est écrit : une collection générée par l’appel d’une fonction, un spread ou un accesseur non analysable, un moteur autre que Postgres ou Firestore, un fichier de sortie existant avec un contenu différent (déplacez-le ou utilisez --force). Un arbre git non propre ou un projet en dehors de git est également refusé, de sorte que la migration forme un diff unique et vérifiable. --json produit l’intégralité du rapport pour un script ou un agent. Voir rebase migrate et Tables.
Les tables générées définissent leurs colonnes selon la syntaxe de pg-core de Drizzle — col.varchar({ length: 160 }), col.timestamp({ withTimezone: true }), col.text().array(), pgEnum(...), .default(sql`…`), .generatedByDefaultAsIdentity() — de sorte que leur résultat n’exige rien de plus ; voir Colonnes. Une table écrite manuellement selon les syntaxes préliminaires de la pré-version 0.31 (col.timestamptz(), col.varchar(160), col.array(col.text()), col.enum(values, { name }), .defaultSql(), .identity(), .column("…")) ne compile plus : tooling/scripts/drizzle-sweep.mts dans le dépôt Rebase la convertit en réécrivant uniquement les chaînes de builders, et prouve avec --verify que chaque table convertie compile vers le même descripteur (npx tsx drizzle-sweep.mts --verify backend/schema).
La passe sdk-calls qui suit réécrit également les sources des règles : existsIn({ collection }) et membership: { collection } deviennent table (section 123) ; --skip-sdk-calls l’ignore également. Ce qui reste à votre charge est affiché sous forme d’étapes manuelles numérotées, et si le projet contient des compétences d’agent installées, la dernière est la ligne rebase skills install qui les actualise (section 128). Un simple rebase migrate affiche l’aide pour les deux sous-commandes.
109. Il n’y a plus de package config
Section intitulée « 109. Il n’y a plus de package config »Qui cela concerne : tous les projets — config/ constituait un workspace à part entière.
La version 0.31 cesse de lire config/collections ; elle n’interdit pas pour autant config/. Le codemod supprime ce que Rebase lisait — les fichiers de collections et la logique déplacée vers backend/ (resources.ts, storage.ts, generated/register.ts, et leurs réexports dans config/index.ts) — et laisse vos propres modules dans config/ là où ils sont, importables comme auparavant : config/ reste un package de workspace, et le backend compile toujours ../config/**/*. Seuls les imports des éléments supprimés sont réécrits : un fichier de collection importé par du code backend pointe vers le module de la table (une étape liste les usages qui le lisent comme un objet) ; importé par du code frontend, il devient un import de type de la table s’il n’est utilisé qu’en tant que type, ou génère une étape indiquant la personnalisation ; un helper situé à l’intérieur de config/collections est copié à côté du code qui en a besoin.
Ce qui a changé : ce qui se trouvait aux côtés des collections est déplacé dans backend/ :
| Avant | Maintenant |
|---|---|
config/resources.ts |
backend/resources.ts |
config/storage.ts, storageAuthorize depuis config/index.ts |
backend/storage.ts |
callbacks exportés depuis config/index.ts |
hooks exportés depuis backend/hooks.ts (TableHooks : table pour collection, values pour row) |
config/generated/register.ts |
backend/generated/register.ts |
rebase.json config, usersCollection |
tables (par défaut backend/schema) ; la table d’authentification est celle déclarée avec defineAuthTable |
Le runtime lit storageAuthorize et hooks et rien d’autre depuis ces modules ; tout autre export est signalé au démarrage. Le frontend importe backend/** sous forme de types uniquement — pnpm check:frontend-backend-imports rejette un import de valeur, ce qui enverrait du code serveur au navigateur.
Ce qu’il faut faire : le codemod déplace resources.ts, storage.ts et l’enregistrement, et réécrit rebase.json, package.json, pnpm-workspace.yaml et backend/tsconfig.json. Les callbacks globaux font l’objet d’une étape manuelle affichée : déplacez-les vers backend/hooks.ts manuellement, et ajoutez hooks.ts au tableau include de backend/tsconfig.json afin que tsc le vérifie. Exécutez ensuite la ligne git rm affichée : git rm -r config/collections …, ou git rm -r config lorsqu’il ne reste plus rien de votre propre code.
110. Les options de démarrage et les hooks nomment des tables
Section intitulée « 110. Les options de démarrage et les hooks nomment des tables »Qui cela concerne : un backend que vous démarrez vous-même (initializeRebaseBackend, createRebaseBackend), et le code qui associe des hooks après le démarrage.
Ce qui a changé :
| Avant | Maintenant |
|---|---|
collections, collectionsDir |
tables, defaultRls, schemaDir |
callbacks |
hooks |
auth.collection |
supprimé : le defineAuthTable dans tables |
backend.setCollectionCallbacks(slug, cb) |
backend.setTableHooks(slug, hooks) |
propriétés de hook collection, row |
table (le descripteur), values |
composeCallbacks |
composeTableHooks depuis @rebasepro/common |
openRebase({ collections, callbacks }) |
openRebase({ tables, hooks }), tables provenant de compileSchema([...]) |
OpenedRebase.collections ; la variable collections de rebase console |
.tables ; tables |
await initializeRebaseBackend({ app, server, collectionsDir: "./config/collections", callbacks });await initializeRebaseBackend({ app, server, schemaDir: path.resolve(__dirname, "../schema"), hooks });Les hooks rattachés à un objet de collection passé à un point d’appel ne s’exécutent plus : le pilote exécute les hooks des tables qu’il sert ; associez-les donc avec setTableHooks.
Ce qu’il faut faire : rebase migrate sdk-calls réécrit setCollectionCallbacks et adapte les propriétés des hooks, puis liste chaque objet d’options de backend à mettre à jour manuellement. Un script qui ouvre les données doit compiler ses tables :
const rebase = await openRebase({ databaseUrl, collections, callbacks });const rebase = await openRebase({ databaseUrl, tables: compileSchema([products, orders]), hooks });Voir Scripts. Voir Vue d’ensemble du backend et Hooks globaux.
111. Le panneau d’administration affiche les tables servies par le serveur
Section intitulée « 111. Le panneau d’administration affiche les tables servies par le serveur »Qui cela concerne : tout frontend qui monte <RebaseCMS>.
Ce qui a changé : <RebaseCMS collections> n’existe plus. Le panneau affiche chaque table que le backend sert sur GET /api/schema/tables, sans nécessiter un fichier par table, suivi des externalCollections (Firestore). tableCustomizations reçoit les objets customizeTable issus de frontend/src/cms/. Le plugin Vite de collections et virtual:rebase-collections sont supprimés. CollectionsProvider accepte les trois mêmes entrées (tableCustomizations, externalCollections, tables).
import { collections } from "virtual:rebase-collections";<RebaseCMS collections={collections}/>import { postsCms } from "./cms/posts";<RebaseCMS tableCustomizations={[postsCms]}/>Ce qu’il faut faire : le codemod écrit frontend/src/cms/index.ts, qui exporte tableCustomizations (et externalCollections), et le monte directement dans le fichier App.tsx d’un scaffold ; un fichier App.tsx non reconnu, le plugin dans vite.config.ts et la déclaration du module virtuel constituent des étapes manuelles affichées. Voir Personnaliser une table.
112. Format de bundle 3 ; les bundles au format 2 sont refusés
Section intitulée « 112. Format de bundle 3 ; les bundles au format 2 sont refusés »Qui cela concerne : tout déploiement d’un bundle compilé — auto-hébergé avec l’image runtime, ou sur Rebase Cloud.
Ce qui a changé : le schéma d’un bundle se trouve dans entry.tables, aux côtés de entry.resources, entry.storage et entry.hooks ; bundleFormat passe à 3 et le contrat du runtime à 2. Un bundle au format 1 ou 2 transporte config/collections, qu’un runtime 0.31 ne peut pas lire ; il refuse donc de démarrer en mentionnant le codemod dans son message d’erreur plutôt que d’introspecter la base de données et de servir une API différente.
Ce qu’il faut faire : migrez le code source, puis lancez rebase build et déployez. Sur Rebase Cloud, le déploiement du dépôt migré déclenche sa reconstruction. Voir Runtime et bundles.
Sur Rebase Cloud, un projet encore en version 0.30 continue de fonctionner mais ne peut plus être déployé. La plateforme continue de servir le bundle en place, et ses mises à jour de runtime s’arrêtent là (la console l’indique), mais elle n’accepte que le format 3 : un déploiement depuis une CLI 0.30 téléverse la totalité du bundle puis est rejeté avec l’erreur BUNDLE_FORMAT_TOO_OLD. La marche à suivre repose sur les trois mêmes commandes pour n’importe quel projet :
pnpm exec rebase upgrade --to latestrebase migrate collections-to-tablesrebase cloud deployUne version de la CLI postérieure à 0.32.0 bloque l’opération plus tôt, avant même de construire ou de téléverser quoi que ce soit : rebase build et rebase cloud deploy sur un projet dont les tables se trouvent toujours dans config/collections s’arrêtent en indiquant le nom du codemod, un argument --bundle-dir contenant un bundle au format 2 est rejeté avec « Nothing was uploaded », et rebase upgrade indique le codemod comme étape suivante au lieu de rebase build. (La commande rebase upgrade propre à la 0.30 se termine toujours par « Run rebase build » ; le build vers lequel elle pointe est précisément celui qui s’interrompt.)
113. La version du schéma est calculée à partir des tables (v2:)
Section intitulée « 113. La version du schéma est calculée à partir des tables (v2:) »Qui cela concerne : toute base de données initialisée par un runtime antérieur à la version 0.31, et tout SDK généré.
Ce qui a changé : la version du schéma hache les descripteurs de tables compilés et commence par v2:. Une base de données marquée v1: signale le changement de modèle une seule fois — le journal de démarrage et rebase doctor l’indiquent en précisant comment réinitialiser l’empreinte — et chaque SDK généré est signalé comme obsolète une fois.
Ce qu’il faut faire : provisionnez une fois avec le nouveau runtime : démarrez le processus propriétaire du schéma, ou exécutez rebase db push. Avec REBASE_REQUIRE_SCHEMA_MATCH=true, réinitialisez l’empreinte avant de basculer les autres processus. Régénérez le SDK.
114. Les codes d’erreur désignent des tables
Section intitulée « 114. Les codes d’erreur désignent des tables »Qui cela concerne : le code qui effectue des branchements conditionnels sur le code d’une erreur.
Ce qui a changé :
| Avant | Maintenant |
|---|---|
NO_COLLECTIONS (404) |
NO_TABLES |
COLLECTION_READ_ONLY (405) |
TABLE_READ_ONLY |
UNKNOWN_COLLECTION (SDK) |
UNKNOWN_TABLE |
INVALID_COLLECTION_PATH (SDK) |
INVALID_TABLE_PATH |
Ce qu’il faut faire : rebase migrate sdk-calls réécrit les chaînes littérales. Voir Erreurs.
115. Le SDK cible une table : data.table(slug)
Section intitulée « 115. Le SDK cible une table : data.table(slug) »Qui cela concerne : tout client, fonction, cron, hook et script qui désigne une table par son slug, ou transmet le dictionnaire généré.
Ce qui a changé :
| Avant | Maintenant |
|---|---|
data.collection(slug) |
data.table(slug) |
createRebaseClient({ collections: collectionsDictionary }) |
createRebaseClient({ tables: tablesDictionary }) |
CollectionName, CollectionsDictionary générés |
TableName, TablesDictionary |
batch { op, collection } (SDK et POST /api/data/_batch) |
{ op, table } |
CollectionClient, SDKCollectionClient, CollectionAccessor, CollectionTrashAccessor |
TableClient, SDKTableClient, TableAccessor, TableTrashAccessor |
mode hors-ligne : maxCachedRowsPerCollection, maxCachedQueriesPerCollection |
…PerTable |
accesseur réservé <name>Collection ; collectionCollection |
<name>Table ; la table collection devient collection |
const { data } = await client.data.collection("posts").find();const { data } = await client.data.table("posts").find();Les accesseurs typés (client.data.posts) restent inchangés.
Ce qu’il faut faire : le codemod applique rebase migrate sdk-calls à votre code — exécutez-le de manière isolée sur un projet déjà migré — puis lancez rebase generate-sdk. Un appel .collection( dont le récepteur n’est pas le SDK est conservé en l’état et répertorié. Voir SDK typé.
116. Options de la CLI : --schema-dir au lieu de --collections
Section intitulée « 116. Options de la CLI : --schema-dir au lieu de --collections »Qui cela concerne : les scripts et les étapes de CI qui appellent la CLI avec un chemin de schéma.
Ce qui a changé : --collections / -c sont refusés sur toutes les commandes qui lisent le schéma, avec mention du codemod dans le message (generate-sdk ignore un --collections-dir résiduel) ; --schema-dir spécifie un répertoire de schéma autre que backend/schema. rebase schema introspect écrit des fichiers defineTable dans backend/schema/ — l’option --output n’existe plus. REBASE_STRICT_COLLECTION_CONFIG n’est plus lu : un schéma qui ne compile pas empêche systématiquement le démarrage.
Ce qu’il faut faire : remplacez les options. Voir CLI et Génération de schéma.
117. L’éditeur de schéma modifie backend/schema avec TablePatch
Section intitulée « 117. L’éditeur de schéma modifie backend/schema avec TablePatch »Qui cela concerne : le code appelant les routes de l’éditeur de schéma ou de schéma dynamique (live-schema), ainsi que les déploiements configurant les variables d’édition en direct.
Ce qui a changé : /api/admin/schema-editor/collection/save, collection/delete, property/save et property/delete ont disparu. L’éditeur sert GET /tables, POST /preview et POST /apply, et les routes /plan et /apply de l’édition dynamique de schéma acceptent { patches: TablePatch[] } au lieu d’une collection ou d’un patch de collection. REBASE_LIVE_SCHEMA_COLLECTIONS_PATH est refusé au démarrage : il est remplacé par REBASE_LIVE_SCHEMA_PATH (par défaut backend/schema), et liveSchema.repository.collectionsPath devient schemaPath. La présentation ne constitue jamais une modification de schéma : elle est enregistrée sous forme de préférences d’interface utilisateur (/api/admin/ui-config). Une modification dont le fichier a changé sur le disque après sa préparation (sauvegarde dans l’EDI, autre processus) renvoie une erreur 409 SCHEMA_EDIT_STALE_FILE et n’écrit rien ; il s’agissait auparavant d’une erreur 400 SCHEMA_EDIT_REFUSED.
Ce qu’il faut faire : renommez la variable ; adaptez les appelants de ces routes pour qu’ils envoient des modifications TablePatch, et rechargez en cas de SCHEMA_EDIT_STALE_FILE. Voir Édition de schéma en direct.
118. Un emplacement de composant est un composant
Section intitulée « 118. Un emplacement de composant est un composant »Qui cela concerne : les personnalisations qui référençaient un composant React par un chemin sous forme de chaîne de caractères ou par une fonction paresseuse () => import(…).
Ce qui a changé : Field / Preview / Filter d’un champ, les Actions de collection, entityViews[].Builder, collectionViews[].Builder, formView.Builder et les surcharges de composants acceptent directement le composant lui-même. ComponentRef, ComponentLike, LazyComponentRef et isLazyComponentRef (@rebasepro/types), asComponentRef et asReactComponent (@rebasepro/cms-types) ainsi que resolveComponentRef / useResolvedComponent (@rebasepro/app) ont été supprimés. customizeTable rejette une chaîne ou un thunk avec le message « imported by value ».
Ce qu’il faut faire : importez le composant dans le fichier frontend/src/cms/ et transmettez-le. Voir Champs personnalisés.
Le codemod effectue cette opération pour chaque chemin textuel et signale chacun d’eux, car un composant importé est vérifié au niveau des types par rapport à son emplacement, ce qui n’était jamais le cas avec un chemin. Un Preview qui déclare customProps?: MyProps échouera au contrôle tsc de votre frontend : l’emplacement transmet customProps avec le type unknown, car rien ne lie les customProps d’un champ au composant qui les lit. Déclarez customProps?: unknown et affinez son type à l’intérieur du composant.
119. Les préférences du panneau sont des préférences d’interface utilisateur (UI)
Section intitulée « 119. Les préférences du panneau sont des préférences d’interface utilisateur (UI) »Qui cela concerne : le code implémentant UserConfigurationPersistence.
Ce qui a changé : la façon dont un utilisateur a redimensionné ou réorganisé une table est un différentiel UiTablePreferences : getTablePreferences / saveTablePreferences remplacent getCollectionConfig / onCollectionModified, et le type partiel de configuration de collection qu’il acceptait est supprimé. Le stockage du navigateur les conserve sous table_preferences::<slug> et ignore ce qu’un ancien panneau avait stocké ; les largeurs de colonnes et modes de vue de chaque utilisateur sont donc réinitialisés une fois. La propriété userSelect sur un champ a disparu : une colonne .userId() fait office de sélecteur d’utilisateur.
La passerelle de Studio s’aligne : StudioSchemaEditing.updateCollection devient applyTablePatches(slug, patches), et l’éditeur de collection transmet { patches } à l’éditeur de schéma.
Ce qu’il faut faire : adaptez toute persistance personnalisée selon les deux méthodes, et convertissez tout StudioSchemaEditing personnalisé vers applyTablePatches.
120. MongoDB est abandonné
Section intitulée « 120. MongoDB est abandonné »Qui cela concerne : tout projet utilisant @rebasepro/server-mongo, ou déclarant database(…, { engine: "mongodb" }).
Ce qui a changé : le package a été supprimé, de même que les types de collection Mongo et le reste du modèle Mongo. Postgres est l’unique moteur de serveur pris en charge : une source de transport serveur utilisant un autre moteur bloque le démarrage en le signalant expressément.
Ce qu’il faut faire : migrez les données vers Postgres. Il n’existe aucun chemin de migration interne au sein de Rebase.
121. Les collections Firestore résident dans le frontend
Section intitulée « 121. Les collections Firestore résident dans le frontend »Qui cela concerne : les projets hybrides utilisant des collections engine: "firestore".
Ce qui a changé : une collection Firestore est une source CMS que le navigateur lit directement : defineFirestoreCollection depuis @rebasepro/firebase, dans frontend/src/cms/, transmis à <RebaseCMS externalCollections>. Une référence entre Firestore et une table Postgres est enregistrée sous forme d’identifiant de la cible, et une référence Firestore dont le path correspond également au slug d’une table Postgres cible désormais la table Postgres.
Ce qu’il faut faire : le codemod écrit les fichiers defineFirestoreCollection. Pointez une référence vers une collection Firestore en utilisant le slug de cette collection. Voir Firebase.
122. Les outils MCP portent le nom des tables
Section intitulée « 122. Les outils MCP portent le nom des tables »Qui cela concerne : les prompts, scripts et listes d’autorisations qui référencent des outils MCP.
Ce qui a changé : /mcp distant : list_collections, describe_collection, query_collection, show_collection, count_documents, aggregate_documents, get_document, create_document, update_document, delete_document → list_tables, describe_table, query_table, show_table, count_rows, aggregate_rows, get_row, create_row, update_row, delete_row ; l’argument collection devient table, et show_app / save_app acceptent tables. Le serveur local : list_documents → query_table, get_document → get_row, create_document → create_row, update_document → update_row, delete_document → delete_row ; rebase_schema_plan accepte patches ; les ressources deviennent rebase://tables/{name}. Le payload de la vue MCP Apps passe en version 3 : descripteurs de tables caviardés selon l’appelant, autorisations par table et préférences d’interface de chaque appelant sous preferences (file, workspace, user ; une clé API n’a pas de couche utilisateur), avec des blocs et des seeds mentionnant table. La vue collection-table est supprimée. list_tables ne comporte pas de title ; describe_table ajoute primaryKey, relations, les rls de l’appelant, title et presentation.
Ce qu’il faut faire : effectuez les renommages. La vue et le serveur doivent communiquer avec la même version de payload : un connecteur hébergé et les environnements d’exécution qu’il joint se mettent à niveau conjointement, et une vue MCP intégrée au projet doit être recompilée avec les packages 0.31. Voir Référence des outils MCP et MCP distant.
123. Le vocabulaire des règles adopte table
Section intitulée « 123. Le vocabulaire des règles adopte table »Qui cela concerne : les règles utilisant policy.existsIn ou un tenant d’appartenance (membership tenant), ainsi que les règles combinant access avec d’autres clauses.
Ce qui a changé : policy.existsIn({ collection, where }) devient existsIn({ table, where }), et tenant.from.membership.collection devient membership.table ; les noms des stratégies restent inchangés. Quatre types de règles accordent désormais des autorisations différentes, dont deux plus étendues (le tableau ci-dessus) : un simple { access: "authenticated" }, qui n’accordait rien, admet désormais tout appelant connecté, et les tables de jonction associées reçoivent leurs stratégies d’écriture de bordure (edge-write). Les règles combinant des clauses exclues par le type SecurityRule, ou portant une valeur invalide pour access, mode, operation ou roles, sont refusées.
Ce qu’il faut faire : le codemod renomme les clés, refuse les règles invalides en indiquant leur fichier et leur ligne, et répertorie les règles qui changent de signification dans la section « Review before deploying ». Pour chacune, conservez-la, écrivez access: "registered" (appelants connectés titulaires d’un compte) ou supprimez-la. Examinez ensuite les résultats de rebase db push --dry-run et rebase doctor --policies sur votre base de données.
124. Studio lit les tables depuis le serveur
Section intitulée « 124. Studio lit les tables depuis le serveur »Qui cela concerne : les instances de Studio pointées vers un backend antérieur à 0.31, ainsi que les scripts de console JS de Studio.
Ce qui a changé : chaque outil interagissant avec le schéma lit GET /api/schema/tables ; face à un environnement d’exécution dépourvu de ce point de terminaison, ils affichent un avis de mise à niveau. La section déclarée de l’éditeur de RLS correspond à ce que le serveur a compilé. Un script de console JS reçoit context.tables (auparavant context.collections).
Ce qu’il faut faire : mettez à niveau le runtime en même temps que le panneau. Voir Studio.
125. rls-check --format agent utilise rls
Section intitulée « 125. rls-check --format agent utilise rls »Qui cela concerne : les outils qui consomment la sortie de rls-check --format agent.
Ce qui a changé : remediation.rebase.securityRules devient remediation.rebase.rls, l’extrait est un defineTable(…, { rls }), et la version du format du document passe à 2. --json reste inchangé. Voir rls-check.
Ce qu’il faut faire : lisez la nouvelle clé.
126. @rebasepro/plugin-review : reviewRls
Section intitulée « 126. @rebasepro/plugin-review : reviewRls »Qui cela concerne : tout projet utilisant le plugin de révision (review plugin).
Ce qui a changé : reviewSecurityRules(slug, review) devient reviewRls(slug, review), injecté dans les rls de la table ; findReviewConfigProblems et assertReviewConfig prennent des descripteurs de table.
Ce qu’il faut faire : renommez l’appel et transmettez services.tables() ou compileTables(…).
127. @rebasepro/codegen lit des descripteurs
Section intitulée « 127. @rebasepro/codegen lit des descripteurs »Qui cela concerne : le code qui appelle directement le générateur.
Ce qui a changé : generateTypedefs(tables) et generateSDK(tables, options) acceptent des TableDescriptor[] — ce que retourne compileTables et ce que dessert GET /api/schema/tables — au lieu de collections.
Ce qu’il faut faire : compilez vos définitions au préalable, ou utilisez rebase generate-sdk.
128. La compétence d’agent rebase-collections devient rebase-tables
Section intitulée « 128. La compétence d’agent rebase-collections devient rebase-tables »Qui cela concerne : tout projet disposant des compétences d’agent installées, ainsi que les prompts ou fichiers d’instructions qui nomment cette compétence.
Ce qui a changé : la compétence enseignant le modèle de données s’appelle désormais rebase-tables : création de tables, colonnes, relations, rls, hooks et couche CMS supérieure. rebase skills install supprime l’ancienne copie rebase-collections, y compris pour les installations effectuées avant l’existence du manifeste de compétences, et conserve tout répertoire portant ce nom que vous auriez créé vous-même.
Ce qu’il faut faire : exécutez rebase skills install après la mise à niveau. Les étapes affichées par rebase migrate collections-to-tables l’indiquent également. Renommez la compétence dans tout fichier d’instructions qui la mentionne. Voir Compétences d’agent.
129. useJsonCollectionsConfigController est supprimé
Section intitulée « 129. useJsonCollectionsConfigController est supprimé »Qui cela concerne : les projets stockant des définitions de collections au format JSON via @rebasepro/cms.
Ce qui a changé : useJsonCollectionsConfigController a disparu, de même que son type d’options et la classe de stockage JSON sous-jacente. Le schéma d’une table réside dans backend/schema, et sa présentation dans le panneau réside dans les préférences de l’interface utilisateur : frontend/src/cms/ui-config.json en cours de développement, table rebase.ui_preferences en production.
Ce qu’il faut faire : déclarez les tables avec defineTable (rebase migrate collections-to-tables les génère à partir des définitions de collections), et transmettez le uiConfig du scaffold à <RebaseCMS>. Voir Personnaliser une table.
130. rebase build refuse un frontend dépourvu de rebaseBackendGuard()
Section intitulée « 130. rebase build refuse un frontend dépourvu de rebaseBackendGuard() »Qui cela concerne : tout projet doté d’un frontend.
Ce qui a changé : le frontend ne peut importer backend/ que sous forme de types. Un import
de valeur introduirait du code serveur — des hooks, ainsi que les secrets qu’ils
consultent — dans le bundle destiné au navigateur. La fonction rebaseBackendGuard() de @rebasepro/app/vitePlugin interrompt vite build et vite dev si un module quelconque du frontend résout un élément dans backend/, en désignant l’importateur, l’import et le fichier concernés, après résolution des alias, des chemins tsconfig, des résolutions de packages et absolues, des globs, de ?raw, des réexports et des imports dynamiques. rebase build, ainsi que le build frontend exécuté par rebase cloud deploy, refusent un frontend dont la configuration Vite ne l’utilise pas ; rebase dev émet un avertissement ; rebase verify signale l’erreur cms-backend-guard-missing.
Ce qu’il faut faire : le codemod l’ajoute dans le fichier frontend/vite.config.ts d’un scaffold, et affiche les lignes requises pour toute autre configuration :
import { rebaseBackendGuard } from "@rebasepro/app/vitePlugin";
export default defineConfig({ plugins: [react()], plugins: [react(), rebaseBackendGuard()],});Transformez ensuite tout import de valeur depuis backend/ en import type.
131. Les lignes en transit suivent le format de leur colonne
Section intitulée « 131. Les lignes en transit suivent le format de leur colonne »Qui cela concerne : les clients lisant des clés étrangères ou désignant des relations, ainsi que les écritures transmettant des colonnes générées ou des objets JSON partiels.
Ce qui a changé : les valeurs traversent le codec de leur colonne en sortie et respectent les règles de la colonne en entrée.
-
Une colonne de clé étrangère
bigintounumericgénérée par une relation, que Postgres renvoie sous forme de texte, est servie sous forme de nombre dans l’API REST, le SDK et le panneau d’administration. Les clés déclarées comme nombres l’étaient déjà. -
Les éléments d’un tableau natif sont servis selon leur type scalaire respectif, dans l’API REST, le SDK, les sockets et le driver :
Colonne 0.30 servait 0.31 sert timestamptz[]["2026-01-02 11:00:00+01"]["2026-01-02T10:00:00.000Z"]numeric[](driver ouvert sans le paramètre numérique de démarrage : tests, scripts)["1.50", "2.25"][1.5, 2.25]bigint[]avec un élément null[1, 0, 3][1, null, 3]date[],timestamptz[]ou tableau d’énumération avec un élément null["2026-01-02", "NULL"]["2026-01-02", null]date[],time[],text[],uuid[],boolean[],integer[]etdouble precision[]sont servis comme auparavant. Ce qui est stocké ne change pas : une ligne lue puis réenregistrée stocke le même tableau. -
Une relation nommée dans
include, dans un filtre ou dans un tri doit correspondre à son nom exact. Les tentatives de résolution basées sur le slug ou sur la notation en snake_case ont été supprimées. -
Une colonne générée est refusée à l’écriture et exclue du schéma d’entrée OpenAPI.
-
Un champ requis à l’intérieur d’un objet JSON est strictement exigé ;
$incet les éléments de tableau sur une colonne entière doivent être des nombres entiers.
Ce qu’il faut faire : lisez les clés étrangères sous forme de nombres là où vous compariez des chaînes, analysez les éléments timestamptz[] au format RFC 3339 et traitez les éléments nuls de tableaux comme null, et orthographiez les noms de relations tels que déclarés par la table (ses clés dans relations). Cessez d’envoyer des colonnes générées.
132. L’historique est servi comme des lectures
Section intitulée « 132. L’historique est servi comme des lectures »Qui cela concerne : les consommateurs d’instantanés d’historique, et toute personne implémentant un DataDriver.
Ce qui a changé : les entrées de l’historique sont servies comme des lectures : accès aux champs d’abord, puis afterRead (global, table, colonne). Une colonne masquée par un hook ou un .transform({ afterRead }) est masquée dans chaque instantané, une colonne que l’appelant ne peut pas lire est omise et exclue de changed_fields, les clés des colonnes supprimées sont exclues, et une restauration n’écrit jamais une colonne que l’appelant n’a pas le droit de lire. Un hook qui lève une exception sur un ancien instantané fait échouer la requête. La version 0.30 servait les valeurs stockées à l’état brut ; un projet utilisant l’historique et des hooks de masquage doit donc impérativement migrer.
Une entrée contient la ligne telle que GET /api/data/<table>/<id> la lit sans aucun include : valeurs brutes, et un belongsTo sous forme de sa clé étrangère. Une entrée qu’une version plus ancienne avait enregistrée avec le modèle de vue du panneau d’administration est servie, et restaurée, telle quelle : une enveloppe { "__type": "date", "value" } pour sa valeur, une référence { "__type": "relation" } d’une relation propriétaire en tant que clé étrangère sous le propre nom de la clé, et toute autre référence sous la forme de la clé de la ligne liée. La version 0.30 servait ces références telles qu’écrites.
Un pilote dessert l’historique via DataDriver.serveStoredRows(path, rows), à l’intérieur de la transaction en lecture seule de l’appelant ; les routes d’historique répondent par une erreur 501 avec un pilote qui ne l’implémente pas, empêchant ainsi tout historique d’être servi sans masquage.
Ce qu’il faut faire : aucune action requise pour le pilote Postgres intégré. Un pilote personnalisé doit implémenter serveStoredRows. Voir Historique.
133. Les exports de @rebasepro/server adoptent les tables
Section intitulée « 133. Les exports de @rebasepro/server adoptent les tables »Qui cela concerne : un serveur assemblé directement à partir des éléments de @rebasepro/server au lieu d’initializeRebaseBackend / createRebaseBackend.
Ce qui a changé :
| Avant | Maintenant |
|---|---|
new RestApiGenerator(collections, …) |
new RestApiGenerator(tables, …) (RestTables) |
mountOpenApiDocs({ collections }), createHistoryRoutes({ collections }) |
mountOpenApiDocs({ serverTables }), createHistoryRoutes({ tables }) |
versionProperty, buildCollection*Schema |
versionColumn, buildTable*Schema ; les validateurs, gestionnaires de conflits et helpers d’ETag acceptent un TableDescriptor |
auth-collection-writes |
auth-table-writes : createUserThroughAuthTable, isAuthTable, prepareAuthTableUpdates, deletingAuthTableUsers |
option de l’adaptateur d’authentification collectionAuthConfig |
authTableHooks (CompiledAuthHooks) |
McpRoutesConfig.getCollections |
getTables() |
assertUploadWithinPropertyLimits, readUploadPropertyContext |
assertUploadWithinColumnLimits, readUploadColumnContext (renvoie { table, column }) ; les détails de refus indiquent column |
provisionCollectionTables, provisionCollectionPolicies, collectionsStoredBy |
provisionTableSchema, provisionTablePolicies, tablesStoredBy |
handGlobalCallbacksTo, warnOnAuthCollectionDataCallbacks |
handGlobalHooksTo, warnOnAuthTableDataHooks |
SchemaEditingAdmin.planSchemaChange(collections, …) |
planSchemaChange(tables, …) avec CompiledTable[] ; EditedSchema.tables |
buildCollectionFromTableMetadata, IntrospectedCollection, IntrospectedRelation |
supprimés : une table introspectée est un TableDescriptor |
createUserThroughAuthCollection ; NestedWriteHop.parentCollection / .targetCollection ; ContractRoutesConfig.collectionRegistry |
createUserThroughAuthTable ; .parent / .target (descripteurs) ; supprimé |
le chargeur de collections : CollectionConfigError, ConfigProblem, applyCollectionDefaults, CollectionDefaults et le type d’options du validateur, accessModelFromCollections, loadBundleConfigExports, BundleConfigExports, unknownKeyPolicyFromEnv, UnknownKeyPolicy |
supprimés : compileSchema / loadBackendSchema chargent et vérifient backend/schema, et un SchemaDefinitionError détaille chaque problème |
Ce qu’il faut faire : renommez. rebase migrate sdk-calls renomme assertUploadWithinPropertyLimits ainsi que les constantes de champs de téléversement (UPLOAD_COLLECTION_FIELD / UPLOAD_PROPERTY_FIELD → UPLOAD_TABLE_FIELD / UPLOAD_COLUMN_FIELD, mêmes valeurs), et répertorie tout autre import ou option de ce tableau sous forme d’étape manuelle numérotée.
134. Les exports de @rebasepro/server-postgres adoptent les tables
Section intitulée « 134. Les exports de @rebasepro/server-postgres adoptent les tables »Qui cela concerne : le code qui initialise lui-même le pilote Postgres, encapsule l’adaptateur ou importe le planificateur de schéma.
Ce qui a changé :
| Avant | Maintenant |
|---|---|
la classe PostgresCollectionRegistry, getTable(name), registerTable |
PostgresTableRegistry, getPgTable, registerPgTable |
openPostgresDriver(config, { collections }) |
openPostgresDriver(config, { tables }), tables provenant de compileSchema ; les appels de pilote ne comportent plus de propriété collection (section 137) |
fonctions de l’adaptateur / bootstrapper : ensureCollectionSchema, ensureCollectionPolicies, readCollectionsSchemaVersion, stampCollectionsSchemaVersion |
ensureTableSchema, ensureTablePolicies, readTablesSchemaVersion, stampTablesSchemaVersion, acceptant CompiledTable[] |
serializePropertyToServer, parsePropertyFromServer |
serializeColumnToServer(value, column) ; parsePropertyFromServer est supprimé — une lecture par le pilote renvoie la ligne REST (section 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 (et les champs de log des alertes de dérive au démarrage) |
.slug, .key |
createStampKeys, sharedRelationName, isAuthCollection, lowerCompiledTables, buildCollectionIndexPlan |
supprimés |
Le JSON généré par le planificateur conserve ses clés : SchemaReconcileColumn.collection et les variantes de SchemaChange restent inchangées.
Ce qu’il faut faire : renommez. Tout wrapper transformant l’adaptateur en un BackendBootstrapper doit relayer ensureTableSchema et ensureTablePolicies. Voir Intégrer le pilote Postgres.
135. @rebasepro/types et @rebasepro/common retirent le modèle de collection de leurs racines
Section intitulée « 135. @rebasepro/types et @rebasepro/common retirent le modèle de collection de leurs racines »Qui cela concerne : le code important des types de collection ou de propriété, des helpers du panneau d’administration ou le lift depuis @rebasepro/types ou @rebasepro/common — champs personnalisés, vues personnalisées, plugins, tests avec fixtures de collection — et les pilotes personnalisés implémentant le registre.
Ce qui a changé : les packages de base (kernel) décrivent désormais uniquement des tables. Ce qui décrit une collection telle que le panneau d’administration la restitue se trouve dans @rebasepro/cms-types :
- Types déplacés depuis
@rebasepro/types:CollectionConfig,PostgresCollectionConfig,FirebaseCollectionConfig,AnyCollectionConfig, chaque type…Property(StringProperty,NumberProperty,ArrayProperty, …) etProperties,CollectionCallbackset ses propriétés de hooks, les types de relations de la version 0.30 et leurs variantesResolved…,CollectionIndex, les couleurs des pastilles (ColorScheme,ColorKey, …),FieldAccess,EnumValues. - Helpers déplacés depuis
@rebasepro/common: les helpers de stratégies propres aux collections (policyToPostgres,compileRulePolicies,getEffectiveSecurityRules,getGeneratedPolicyNames, …),CollectionRegistry,resolveCollectionRelations,resolveRelation,getTableName,findRelation,rowToViewModel,resolvePrimaryKeys, la vue d’accès aux champs d’une propriété (effectiveAccess,canReadField,canWriteField),evaluateCondition,canEditEntity,resolveProperty,getDefaultValuesFor,getSubcollections,getCopyValues,enumToObjectEntries. Une règle compilée depuis une simple expression utilisecompilePolicyExpression(expr)issu de@rebasepro/common. composeCallbackscompose les callbacks d’une collection pour le panneau et a été déplacé dans@rebasepro/cms-types;@rebasepro/serverne le réexporte plus. Le code backend compose les hooks d’une table aveccomposeTableHooksdepuis@rebasepro/common, et le codemod signale tout import decomposeCallbacksdans le backend sous forme d’étape manuelle.defineCollectionest supprimé de@rebasepro/commonet@rebasepro/cms-types: déclarez la table avecdefineTabledansbackend/schemaet personnalisez-la aveccustomizeTabledansfrontend/src/cms; une collection Firestore s’écrit avecdefineFirestoreCollectionissu de@rebasepro/firebase.- L’accesseur du panneau d’administration et ses types :
Entity,EntityValues,TableAccessor,TableTrashAccessor,FindResponse,QueryBuilderInterface,RebaseDataetAuthStatequittent@rebasepro/types;buildRebaseData,wrapAsEntityData,buildRoutedRebaseData,EntityDataOptions,QueryBuilder,RelationRefetcreateRelationRefquittent@rebasepro/common. Tous s’importent depuis@rebasepro/cms-types. La couche de données propre au SDK —buildSdkData,createDriverTableRows,buildRoutedSdkData, dans@rebasepro/common— sert directement les lignes et retourne le même format qu’auparavant. EntityDataOptions.resolveCollectionest remplacé parprimaryKeysOf,viewModelOf,storedValuesOfetviewModelSourceOf;collectionEntityDataOptions(resolveCollection, { resolveDataPath, resolveAccessor })issu de@rebasepro/cms-typesles construit.- Le convertisseur de migration (lift) (
collectionsToTableDefs,collectionToTableDef,LiftNote,LiftResult,LiftOptions) a été déplacé dans@rebasepro/common/migrate, aux côtés d’une copie figée du modèle de collection 0.30 (les typesLegacy…) et dedefineLegacyCollection. - Également supprimés de la racine du noyau, chacun étant signalé par le codemod comme étape manuelle : l’API de patch de collection de
@rebasepro/types(CollectionPatch,CollectionPatchOp,applyCollectionPatch,collectionPatchProblems,isCollectionPatch,nestCollectionPatchPaths→TablePatch), ses helpers JSON de collection (diffCollections,diffJsonValues,toCollectionJson,RUNTIME_ONLY_COLLECTION_KEYS,runtimeOnlyKeyIn), les éléments de l’époque MongoDocumentAdmin,isDocumentAdminet la fonctionnalitésupportsDocumentAdmin, ainsi queRebaseProjectContract.collectionSlugs/.collections/.generatedAt(/api/meta/contractserttables) ; dans@rebasepro/common,buildTenantSecurityRule→tenantSecurityRule,defaultPoliciesDisabled→tableDefaultPoliciesDisabled,restoresSoftDeletedRow→isSoftDeleteRestore,softDeleteFieldOf→softDeleteColumn,getJunctionConfigForRelation→resolveTableJunctions, etisRelationRequired,relationDeclaringProperty,requireCallbackCollectionsans équivalent direct (consultez leTableDescriptor). - Le registre d’un pilote est une
TableRegistryInterface(auparavantCollectionRegistryInterface) :setGlobalHooks?etsetTableHooks?remplacentgetGlobalCallbacks/setGlobalCallbacks?.globalHooksAsCallbacks,resolveDriftCheckNameetPENDING_TABLE_FEATURESont été retirés.
Ce qu’il faut faire : rebase migrate sdk-calls (inclus dans collections-to-tables) déplace chaque import ci-dessous vers son nouveau package — fusionné avec un import existant de ce package s’il est déjà présent dans le fichier, tout en conservant import type, les type en ligne et les alias as — et ajoute le package aux dépendances du package de workspace concerné ; exécutez pnpm install ensuite. Un import d’un nom supprimé, un import avec espace de noms (import * as), un export *, un import() dynamique ou un require() utilisant un nom déplacé constitue une étape manuelle numérotée. Un test conservant des littéraux de collection comme fixtures doit les typer avec les types Legacy… et les transformer via @rebasepro/common/migrate.
Imports ayant changé d’emplacement
Section intitulée « Imports ayant changé d’emplacement »Chaque nom déplacé par la version 0.31 vers un autre package, ou supprimé, est répertorié sur la page Imports déplacés dans la version 0.31, avec la marche à suivre pour chaque élément retiré. Cette liste est générée à partir de la table de correspondance exacte lue par le codemod, et correspond donc fidèlement à ce que rebase migrate sdk-calls réécrit.
136. Le pilote Postgres et les lectures ponctuelles de la socket renvoient la ligne REST
Section intitulée « 136. Le pilote Postgres et les lectures ponctuelles de la socket renvoient la ligne REST »Qui cela concerne : toute fonction ou plugin effectuant des lectures via requireDriver(c) / getDriver(c), le code émettant les trames FETCH_COLLECTION / FETCH_ONE de la socket, et le code lisant des objets { __type } depuis une réponse.
Ce qui a changé : il n’existe plus qu’un seul format de lecture. fetchCollection et fetchOne sur le pilote Postgres — utilisés par le requireDriver(c) d’une fonction, les plugins, les trames ponctuelles de la socket, MCP et le simulateur de RLS — renvoient exactement ce que GET /api/data/<table> retourne :
| Valeur | Lecture par le pilote en 0.30 | 0.31 |
|---|---|---|
| un timestamp | { "__type": "date", "value": … } |
une chaîne RFC 3339 |
un belongsTo |
{ "__type": "relation", "id", "path" } sous le nom de la relation |
la clé étrangère sous sa propre clé (authorId) |
| une ligne liée | chaque relation chargée par fetchOne |
uniquement les relations listées par include, sous forme de la ligne cible |
un vecteur, un bytea |
{ "__type": "Vector" }, une data URL |
selon le format servi par REST |
FetchOneProps prend en charge include (ListenOneTarget est supprimé : utilisez FetchOneProps). rebase.data, context.data et le SDK renvoyaient déjà ce format et restent inchangés.
@rebasepro/client traite les corps de requêtes REST et les trames de socket comme du JSON standard : une valeur contenant une clé __type n’est plus convertie en Date, EntityReference, EntityRelation, GeoPoint ou Vector, et un document JSON contenant une clé __type est restitué tel qu’il est stocké.
Ce qu’il faut faire : lisez la ligne brute : convertissez les dates depuis leurs chaînes de caractères, lisez une clé étrangère directement depuis sa propre clé, et spécifiez include pour chaque relation à récupérer :
const article = await requireDriver(c).fetchOne({ path: "articles", id });const authorId = article?.author.id; // a { __type: "relation" } refconst article = await requireDriver(c).fetchOne({ path: "articles", id, include: ["author"] });const authorId = article?.authorId;137. Les interfaces de pilote et de backend transportent des tables, et non des collections
Section intitulée « 137. Les interfaces de pilote et de backend transportent des tables, et non des collections »Qui cela concerne : un DataDriver personnalisé, un adaptateur de base de données, ou un backend assemblé à partir des briques de @rebasepro/server.
Ce qui a changé :
| Avant | Maintenant |
|---|---|
la propriété collection des appels DataDriver (fetch, save, delete, count, search, listen) |
supprimée : le pilote résout la table qu’il sert via path |
checkUniqueField(path, name, value, id, collection) |
checkUniqueField(path, name, value, id?) |
scanStoredRows({ path, collection, pageSize }) |
scanStoredRows({ path, pageSize }) |
DataDriver.initTextSearch |
supprimé |
DatabaseAdapterInitConfig.collections, .collectionRegistry |
supprimés : l’adaptateur reçoit CompiledTable[] |
BackendServices.collections() |
services.tables() |
serializeCollections, deserializeCollections, isSerializedCollectionRef, SerializedCollectionRef |
supprimés : les descripteurs sont exposés sur GET /api/schema/tables |
AuthAdapter.prepareUserCreation(values, collectionAuth, options?), describeUserCreationContract(collectionAuth) |
prepareUserCreation(values, options?), describeUserCreationContract() |
initializeDriver retournant { driver, collectionRegistry, … } ; BackendInstance.collectionRegistry |
{ driver, tableRegistry, … } ; BackendInstance.tableRegistry |
PolicyEvalContext.entity (une Entity) |
PolicyEvalContext.row (les valeurs de la ligne) |
wrapAsSdkData(…) |
buildSdkData(driver) ; sources de données multiples : buildRoutedSdkData |
FindResponse issu de @rebasepro/client |
FindResult |
ListenCollectionRequest, ListenEntityRequest issus de @rebasepro/server |
ListenCollectionProps, ListenOneProps |
Ce qu’il faut faire : retirez ces arguments et interrogez les tables par leur path. Le codemod signale implements DataDriver sous forme d’étape manuelle. Voir Intégrer le pilote Postgres.
138. Le backend n’accepte que les valeurs documentées par l’API REST, et rien d’autre
Section intitulée « 138. Le backend n’accepte que les valeurs documentées par l’API REST, et rien d’autre »Qui cela concerne : tout client transmettant une relation to-one sous forme d’objet ou un vecteur sous la forme { value }, le code filtrant une relation avec un objet, le code important les classes de valeurs d’administration, et toute application hors ligne ayant mis des écritures en file d’attente sous 0.30.
Ce qui a changé : une écriture adopte le format exact retourné par une lecture — une structure d’écriture unifiée pour REST, les sockets, MCP et le SDK in-process :
| Valeur | Accepté | Refusé désormais |
|---|---|---|
une relation to-one (belongsTo, hasOne, un via to-one) |
la clé de la ligne liée, ou null ("" équivaut à null), sous le nom de la relation ou de la clé étrangère |
un objet tel que { "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. » |
une relation to-many (hasMany, manyToMany, un via to-many modifiable) |
une liste de clés, ou une liste de { id, _pivot? } |
— (les autres clés présentes sur l’objet sont ignorées, comme auparavant) |
| un vecteur | une liste de nombres | un Vector, ou { "value": [...] } : 400, « ‘embedding’ expects a vector as a list of numbers » |
| une date, une heure | chaîne ISO (Date dans le même processus) |
— |
| un géopoint | { latitude, longitude } |
— |
un bytea |
une URL data:application/octet-stream;base64, (Buffer / Uint8Array dans le même processus) |
— |
| un filtre sur une relation | la clé | un objet n’est plus déballé automatiquement : il est comparé tel quel |
La version 0.30 acceptait une relation to-one écrite sous forme d’objet et extrayait silencieusement son champ id ; cette syntaxe n’a jamais été documentée et relevait du modèle de vue du panneau d’administration. Désormais, le panneau d’administration convertit son modèle de vue au format réseau dans le navigateur avant chaque écriture et filtrage.
Les classes de valeurs d’administration ont suivi le reste de son modèle de vue : EntityReference, EntityRelation, GeoPoint, Vector et EntityReferenceProps s’importent depuis @rebasepro/cms-types (elles ne font plus partie de @rebasepro/types), de même que normalizeToEntityRelation (retiré de @rebasepro/common) ; withRelationReferencesOnly a été supprimé. L’historique stocke la ligne telle qu’une lecture la renvoie ; les entrées enregistrées auparavant sont servies et restaurées sous forme de valeurs brutes (section 132).
La file d’attente hors ligne de @rebasepro/client stocke désormais des valeurs réseau. Une écriture mise en attente hors ligne par le SDK 0.30 est convertie lors de sa relecture et de son rejeu : aucune opération en attente avant la mise à niveau n’est perdue.
Ce qu’il faut faire : transmettez la clé : { "author": 5 }, et non { "author": { "id": 5 } } ; transmettez un vecteur sous la forme d’une liste de nombres, et filtrez une relation par sa clé. rebase migrate sdk-calls déplace les imports des classes de valeurs (la liste). Voir Écritures.
139. /api/docs est servi au public du endpoint de schéma
Section intitulée « 139. /api/docs est servi au public du endpoint de schéma »Qui cela concerne : toute personne ou outil qui consulte /api/docs ou ouvre /api/swagger — Swagger UI, générateurs de clients d’API, étapes de CI.
Ce qui a changé : lorsque enableSwagger n’est pas défini (REBASE_ENABLE_SWAGGER non défini), dans tous les environnements, le document OpenAPI est servi aux mêmes appelants que ceux auxquels GET /api/schema/tables décrit les tables, avec les mêmes refus — 401 pour un appelant anonyme à moins que schemaTables.public ne soit actif, 403 pour des identifiants dépourvus de portée schema ou data — et chaque appelant reçoit la documentation décrivant précisément les tables, colonnes et relations que ce point de terminaison lui expose (un administrateur reçoit l’ensemble). L’interface Swagger UI n’est plus fournie. Un serveur configuré sans authentification répond 404 DOCS_UNAVAILABLE. En 0.30, l’intégralité du document, décrivant toutes les tables servies et les colonnes non privées, était exposée aux utilisateurs anonymes en développement, et restreinte aux seuls administrateurs en production.
enableSwagger / REBASE_ENABLE_SWAGGER |
/api/docs |
/api/swagger |
|---|---|---|
| non défini (par défaut) | chaque appelant auquel l’endpoint de schéma décrit des tables : ses tables | non servi |
true |
l’intégralité du document, accessible à tous | servi hors production |
false |
l’intégralité du document, protégé par le contrôle d’accès administrateur | non servi |
Ce qu’il faut faire : appelez /api/docs en étant authentifié. Pour publier le document complet comme le faisait la 0.30 en développement, définissez REBASE_ENABLE_SWAGGER=true (ou enableSwagger: true). Voir Endpoints.
140. Une colonne pivot de type many-to-many ne peut pas déclarer .transform()
Section intitulée « 140. Une colonne pivot de type many-to-many ne peut pas déclarer .transform() »Qui cela concerne : tout rel.manyToMany(…, { pivot: { … } }) dont la colonne pivot comporte un .transform().
Ce qui a changé : le compilateur la rejette (« the pivot column “x” declares .transform() … »). La transformation d’une colonne pivot n’était exécutée nulle part ; une valeur que vous souhaitiez masquer était donc servie telle qu’elle était enregistrée.
Ce qu’il faut faire : retirez .transform() et masquez _pivot dans le hooks.afterRead de la table cible. Voir Relations.
141. Un lien possède exactement les mêmes droits de lecture et d’écriture que sa colonne clé
Section intitulée « 141. Un lien possède exactement les mêmes droits de lecture et d’écriture que sa colonne clé »Qui cela concerne : tout client qui écrit un belongsTo via son nom de relation, lit ou filtre une relation dont la colonne clé fait l’objet de restrictions, ou s’appuie sur strictWrites: false.
Ce qui a changé : une restriction portant sur une colonne clé s’applique à toutes les syntaxes qui la lisent ou la modifient.
- Définir un lien via son nom de relation (
{ "reviewer": 7 }) est soumis à l’ensemble des règles de la colonne clé qu’il alimente —.readOnly(),.private(),access.write, horodatages de création, colonne de tenant, immutabilité de la clé — que ce soit sur REST, en traitement en bloc (bulk), sur_batch, via socket ou MCP. Spécifier le lien sous ses deux dénominations ({ "reviewer": 7, "reviewerId": 8 }) avec des valeurs discordantes déclenche une erreur 400VALIDATION_INVALID_VALUE. Déplacer une ligne vers un autre tenant par l’intermédiaire de son lien renvoie une erreur 400TENANT_IMMUTABLE(il s’agissait auparavant d’une 500). - Une relation n’est lisible que si l’appelant est autorisé à lire chaque colonne mobilisée par sa jointure, sur l’ensemble des tables traversées : la clé du
belongsTo, la clé étrangère cible pour unhasMany/hasOne, et chaque colonne jointe par les étapes d’unvia. Si l’une d’elles échoue, elle est omise deincludeet de_count, et toute tentative de filtrage, de tri ou de traversée de chemin de relation déclencheFIELD_NOT_READABLE(ou relation inconnue si la colonne est.private()). Une écriture to-one viaviaqui copierait une colonne non lisible par l’appelant est refusée avecFIELD_NOT_READABLE. Les cas inverses etviaétaient déjà possibles en 0.30.x. - Un lien dont la colonne clé n’est pas lisible par l’appelant est écarté de
include, et tout filtre, tri, entrée defieldsou chemin de relation l’empruntant renvoieFIELD_NOT_READABLE; un lien rattaché à une clé.private()est considéré comme une relation inexistante.GET /api/schema/tables, OpenAPI et MCPdescribe_tabledécrivent un lien et sa clé conjointement ; une colonne clé dont le lien est fermé y est par conséquent également masquée. strictWrites: falsene tranche qu’une seule chose : une clé non déclarée est directement transmise au pilote (écrite si la colonne existe dans la base, sinon erreur 400VALIDATION_UNKNOWN_FIELDS). Elle n’ouvre en aucun cas une colonne déclarée, un horodatage, le tenant, la clé, la cible d’une relation ou une règle_pivot.
Ce qu’il faut faire : écrivez un lien sous un seul nom, ou sous les deux avec une valeur identique ; lisez les liens restreints à l’aide d’un rôle disposant des droits de lecture sur leur clé. Voir Accès aux champs.