Aller au contenu

Upgrading

Mise à niveau de 0.30 à 0.31

Depuis 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.

  1. 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", puis pnpm 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 dossier config/ 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.

  2. 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 dans config/.

  3. Exécutez-le pour de bon : rebase migrate collections-to-tables. Il écrit backend/schema/, frontend/src/cms/ (avec ui-config.json), les modules backend/ et les fichiers du projet, ajoute rebaseBackendGuard() au fichier vite.config.ts du 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.

  4. 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).

  5. 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> avec tableCustomizations et uiConfig lorsque votre App.tsx n’est pas celui du scaffold (ou lorsque le panneau est monté dans un autre module, que l’étape indique), rebaseBackendGuard() lorsque votre vite.config.ts n’est pas celui d’origine et dans toutes les autres applications statiques de rebase.json (section 130), les hooks globaux, l’import d’un nom supprimé par la version 0.31 (section 135), et rebase skills install lorsque le projet contient des compétences d’agent (section 128). Exécutez pnpm install lorsque 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 .data avec un nom de table littéral ; le membre collection d’un type contenu dans un emplacement data / 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 si collection existe (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 .js packagé 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 ; --json conserve 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.

  6. Exécutez la ligne git rm affichée par le codemod une fois le diff examiné et la commande rebase migrate collections-to-tables --check validée : git rm -r config/collections … et la configuration déplacée vers backend/, ou git rm -r config lorsqu’il ne reste plus rien de personnalisé à cet endroit (section 109). Les trois étapes suivantes en ont besoin : generate-sdk, db push, doctor et verify refusent un projet contenant encore config/collections.

  7. rebase generate-sdk — les noms du module généré ont changé (section 115).

  8. Sur votre base de données, exécutez rebase db push --dry-run et attendez-vous au message « No changes: the database already matches these tables. », puis rebase doctor --policies en 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.

  9. rebase verify — lit désormais également frontend/src/cms : une personnalisation ciblant une table ou un champ inexistant, une colonne obligatoire absente du formulaire, un rebaseBackendGuard() manquant, un fichier ui-config.json non transmis à <RebaseCMS>.

  10. 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é.

  • Ce que GET /api/schema/tables renvoie à un utilisateur. Les administrateurs et les détenteurs de schema:read obtiennent 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’option schemaTables: { 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 affichait created_at perd cette colonne tant que vous n’ajoutez pas fields: { created_at: { hidden: false } } dans son customizeTable. Le codemod refuse, avec indication du motif, les tableaux JSON de tuples, un type vector / binary / reference à l’intérieur d’une map, databaseId sur une collection Postgres, isId: "cuid", une relation isId unique et disableDefaultPolicies: true sans aucune règle. Une relation sur une seule colonne vers une table avec clé composite est refusée (déclarez-la avec rel.via()). Les tags OpenAPI proviennent du slug, et non du nom d’affichage. rebase schema introspect omet 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éclarant roles provoque 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 push ou démarrage recrée ces stratégies une seule fois, avec les mêmes noms et le même SQL.
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 first

La 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é) deviennent hooks: 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, les const, les lectures de propriétés et un simple return). Lorsqu’il ne peut pas suivre le helper, une étape indique les hooks à vérifier.
  • Une fonction storagePath migre en deux moitiés : la fonction devient le storage.path de la personnalisation afin que le panneau continue de choisir l’emplacement de téléversement, et le modèle path de 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ésormais maxBytes et accept de 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, et auth: { collection: usersCollection } dans une entrée de backend personnalisée est supprimé (le defineAuthTable constitue la table d’authentification). Une option de démarrage collections devient schemaDir.
  • Un générateur de dynamicProps renvoie 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 de config/ (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 en defineFirestoreCollection dè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 encore path.
  • Les imports de config/ via un alias de chemin (une entrée paths de tsconfig, un resolve.alias de Vite) sont réécrits ou listés de la même façon que les chemins relatifs, et une fonction storageAuthorize réexportée par config/index.ts est déplacée vers backend/storage.ts.
  • Une relation renommée en <key>Relation conserve 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.

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 latest
rebase migrate collections-to-tables
rebase cloud deploy

Une 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.

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.

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.

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.

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.

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.

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.

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.

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é.

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(…).

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 bigint ou numeric gé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[] et double 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é ; $inc et 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.

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, …) et Properties, CollectionCallbacks et ses propriétés de hooks, les types de relations de la version 0.30 et leurs variantes Resolved…, 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 utilise compilePolicyExpression(expr) issu de @rebasepro/common.
  • composeCallbacks compose les callbacks d’une collection pour le panneau et a été déplacé dans @rebasepro/cms-types ; @rebasepro/server ne le réexporte plus. Le code backend compose les hooks d’une table avec composeTableHooks depuis @rebasepro/common, et le codemod signale tout import de composeCallbacks dans le backend sous forme d’étape manuelle.
  • defineCollection est supprimé de @rebasepro/common et @rebasepro/cms-types : déclarez la table avec defineTable dans backend/schema et personnalisez-la avec customizeTable dans frontend/src/cms ; une collection Firestore s’écrit avec defineFirestoreCollection issu de @rebasepro/firebase.
  • L’accesseur du panneau d’administration et ses types : Entity, EntityValues, TableAccessor, TableTrashAccessor, FindResponse, QueryBuilderInterface, RebaseData et AuthState quittent @rebasepro/types ; buildRebaseData, wrapAsEntityData, buildRoutedRebaseData, EntityDataOptions, QueryBuilder, RelationRef et createRelationRef quittent @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.resolveCollection est remplacé par primaryKeysOf, viewModelOf, storedValuesOf et viewModelSourceOf ; collectionEntityDataOptions(resolveCollection, { resolveDataPath, resolveAccessor }) issu de @rebasepro/cms-types les 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 types Legacy…) et de defineLegacyCollection.
  • É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 Mongo DocumentAdmin, isDocumentAdmin et la fonctionnalité supportsDocumentAdmin, ainsi que RebaseProjectContract.collectionSlugs / .collections / .generatedAt (/api/meta/contract sert tables) ; dans @rebasepro/common, buildTenantSecurityRule → tenantSecurityRule, defaultPoliciesDisabled → tableDefaultPoliciesDisabled, restoresSoftDeletedRow → isSoftDeleteRestore, softDeleteFieldOf → softDeleteColumn, getJunctionConfigForRelation → resolveTableJunctions, et isRelationRequired, relationDeclaringProperty, requireCallbackCollection sans équivalent direct (consultez le TableDescriptor).
  • Le registre d’un pilote est une TableRegistryInterface (auparavant CollectionRegistryInterface) : setGlobalHooks? et setTableHooks? remplacent getGlobalCallbacks / setGlobalCallbacks?. globalHooksAsCallbacks, resolveDriftCheckName et PENDING_TABLE_FEATURES ont é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.

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" } ref
const 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 400 VALIDATION_INVALID_VALUE. Déplacer une ligne vers un autre tenant par l’intermédiaire de son lien renvoie une erreur 400 TENANT_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 un hasMany / hasOne, et chaque colonne jointe par les étapes d’un via. Si l’une d’elles échoue, elle est omise de include et de _count, et toute tentative de filtrage, de tri ou de traversée de chemin de relation déclenche FIELD_NOT_READABLE (ou relation inconnue si la colonne est .private()). Une écriture to-one via via qui copierait une colonne non lisible par l’appelant est refusée avec FIELD_NOT_READABLE. Les cas inverses et via é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 de fields ou chemin de relation l’empruntant renvoie FIELD_NOT_READABLE ; un lien rattaché à une clé .private() est considéré comme une relation inexistante. GET /api/schema/tables, OpenAPI et MCP describe_table décrivent un lien et sa clé conjointement ; une colonne clé dont le lien est fermé y est par conséquent également masquée.
  • strictWrites: false ne 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 400 VALIDATION_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.