Upgrading
Aggiornamento da 0.30 a 0.31
Aggiornamento 0.30 → 0.31
Sezione intitolata “Aggiornamento 0.30 → 0.31”La versione 0.31 rende il backend Postgres-first. Le tabelle dichiarate con defineTable in backend/schema/ sono l’unica cosa che il backend conosce riguardo ai tuoi dati; ciò che il pannello di amministrazione mostra al di sopra di esse risiede nel frontend. Quasi ogni voce seguente è una conseguenza di questa separazione, e quasi tutto viene gestito automaticamente da un singolo comando.
La checklist, per progetto
Sezione intitolata “La checklist, per progetto”-
Aggiorna prima ogni pacchetto
@rebasepro, in ogni pacchetto del workspace, in modo che i tipi letti dal codemod siano quelli di 0.31:pnpm -r up "@rebasepro/*@0.31.0", poipnpm install. Un progetto su una versione precedente a 0.30 deve prima applicare le modifiche al codice indicate nelle guide intermedie (Aggiornamento) e soddisfare i requisiti minimi della toolchain di 0.31 — Node 22.22, TypeScript 6, React 19.2.7, React Router 8, Vite 8 (l’elenco): il codemod carica una cartellaconfig/di 0.20–0.29 e il suo controllo SQL passa, ma quel controllo confronta il compilatore 0.31 con se stesso — solo il passaggio 7, eseguito contro il tuo database reale, dimostra che il DDL generato corrisponde a quello presente nel database. -
Esegui il commit, poi avvia il codemod in modalità simulata (dry run):
rebase migrate collections-to-tables --dry-run. Questo comando elenca i file che scriverebbe, ciò che rifiuta (con file e riga), le note e i passaggi manuali, senza scrivere nulla. Correggi prima inconfig/ciò che viene rifiutato. -
Eseguilo realmente:
rebase migrate collections-to-tables. Scrivebackend/schema/,frontend/src/cms/(conui-config.json), i moduli dibackend/e i file di progetto, aggiungerebaseBackendGuard()alvite.config.tsdello scaffold, riscrive le chiamate SDK, sposta le importazioni dei nomi che 0.31 ha trasferito in un altro pacchetto (sezione 135), e verifica che l’SQL generato sia identico byte per byte — altrimenti ripristina ogni file. Vedi la sezione 108. -
Leggi l’ultima sezione del suo output, “Review before deploying: these rules change meaning”, e decidi per ogni regola elencata (sotto).
-
Esegui i passaggi manuali stampati, nell’ordine indicato. Ognuno specifica il file di riferimento, e la maggior parte include lo snippet da inserire: il mount di
<RebaseCMS>contableCustomizationseuiConfigquandoApp.tsxnon è quello dello scaffold (o il pannello è montato in un altro modulo, indicato nel passaggio),rebaseBackendGuard()quandovite.config.tsnon è quello standard e in ogni altra app statica direbase.json(sezione 130), gli hook globali, l’importazione di un nome rimosso da 0.31 (sezione 135), erebase skills installse il progetto contiene agent skill (sezione 128). Eseguipnpm installquando l’output riporta “Dependencies added”. Poi leggi due elenchi nella parte dell’output relativa all’SDK:- “Rewritten by name — review”: chiamate
.collection(su un ricevitore senza tipo (any), riscritte perché il ricevitore si chiamadataAsAdmin, o è.datacon un nome tabella letterale; il membrocollectiondi un tipo contenuto in uno slotdata/dataAsAdmin; e i test double. Controlla che ciascuno sia effettivamente l’SDK. - “Left unchanged — check each”: chiamate
.collection(per cui il codemod non ha potuto confermare l’appartenenza all’SDK, come una chiamata tramite un tipo dichiarato dal progetto stesso. Una chiamata lasciata qui che è effettivamente l’SDK fallirà a runtime su 0.31: rinominala manualmente in.table(. Il codice che verifica secollectionesiste (typeof data.collection === "function") è un passaggio manuale: su 0.31 prenderà silenziosamente l’altro ramo.
Un file committato come output di build (un
.jsimpacchettato o minificato) non viene mai modificato: viene elencato, quindi ricompilalo dopo la migrazione e sostituisci le copie vendorizzate del client con la build di 0.31. I passaggi ripetuti dello stesso tipo vengono stampati una volta sola, elencando ogni file e riga a cui si riferiscono;--jsonmantiene ciascun passaggio separato. Poi leggi Cosa i progetti hanno modificato manualmente: le modifiche che i progetti reali hanno comunque dovuto apportare dopo questi passaggi. - “Rewritten by name — review”: chiamate
-
Esegui la riga
git rmstampata dal codemod una volta revisionato il diff e dopo cherebase migrate collections-to-tables --checkha avuto esito positivo:git rm -r config/collections …e la logica di collegamento spostata inbackend/, oppuregit rm -r configse non rimane nulla di personalizzato al suo interno (sezione 109). I successivi tre passaggi richiedono che questo sia fatto:generate-sdk,db push,doctoreverifyrifiutano un progetto che contiene ancoraconfig/collections. -
rebase generate-sdk— i nomi del modulo generato sono cambiati (sezione 115). -
Contro il tuo database, esegui
rebase db push --dry-rune attenditi “No changes: the database already matches these tables.”, poirebase doctor --policiese attenditi nessun drift nelle policy. Il controllo SQL del codemod attesta la fedeltà della conversione; questi due passaggi la verificano contro il database reale, e qualsiasi differenza di policy elencata rappresenta una modifica a chi può accedere a cosa. -
rebase verify— ora legge anchefrontend/src/cms: una personalizzazione che fa riferimento a una tabella o un campo inesistente, una colonna obbligatoria esclusa dal form, unrebaseBackendGuard()mancante, unui-config.jsonnon passato a<RebaseCMS>. -
Ricompila ed effettua il deploy. Un bundle compilato prima della 0.31 non si avvia su un runtime 0.31 (sezione 112). Il primo avvio aggiorna una tantum il timestamp della versione dello schema del database (sezione 113).
Esegui rebase migrate collections-to-tables --check nella CI fino alla rimozione di config/: verifica che le tabelle migrate generino ancora lo stesso SQL delle collection da cui provengono, ed esce con codice 1 se una regola elencata sotto “Review before deploying” non è stata confermata — passa --accept-rule-changes dopo averle esaminate.
Revisione prima del deploy: queste regole cambiano significato
Sezione intitolata “Revisione prima del deploy: queste regole cambiano significato”Il codemod trasferisce ogni regola di sicurezza così com’è scritta, e ciascuna mantiene il nome della propria policy. Tuttavia, il compilatore di 0.30 leggeva solo il primo elemento tra condition, using, access: "public" e ownerField, e non conosceva altri valori di access, quindi quattro tipologie di regole ora concedono permessi differenti. Due di esse ampliano l’accesso:
| La regola | 0.30 concedeva | 0.31 concede | |
|---|---|---|---|
un semplice access: "authenticated" (senza roles) |
nulla | qualsiasi chiamante autenticato, inclusi i guest | amplia |
access + check, senza condition, su select / update / delete / all |
nessuna riga esistente | ogni riga esistente, ai chiamanti di access |
amplia |
access: "authenticated" + condition |
chiunque soddisfacesse la condition |
solo i chiamanti autenticati che la soddisfano | restringe |
access: "authenticated" + check, su insert |
chiunque inserisse una riga corrispondente | solo chiamanti autenticati | restringe |
Il caso più comune è il primo. Scrivi access: "registered" per consentire l’accesso solo ai chiamanti con un account (escludendo i guest anonimi), oppure rimuovi la regola per continuare a non concedere nulla. access con roles, e un plain object per condition, mantengono il significato precedente e non sono elencati.
Il codemod rifiuta inoltre qualsiasi regola rifiutata dal compilatore 0.31: quelle che combinano clausole escluse dal tipo SecurityRule (access assieme a ownerField, using o withCheck; ownerField assieme a using, withCheck, condition o check; condition o check assieme a using o withCheck), e quelle con un valore non valido per access, mode, operation(s) o roles — in precedenza un errore di battitura come "restrictive" veniva compilato come permissivo. Vedi Regole di sicurezza.
Altre differenze di comportamento
Sezione intitolata “Altre differenze di comportamento”- Cosa comunica
GET /api/schema/tablesa un utente. Gli amministratori e chi possiedeschema:readricevono tutte le tabelle. Qualsiasi altro utente autenticato, guest inclusi, riceve solo le tabelle raggiungibili dai propri ruoli, con solo le regole a lui applicabili; le relazioni verso altre tabelle vengono omesse e i flag degli hook nascosti. Un frontend che leggeva la descrizione di un’altra tabella come utente standard riceve meno dettagli; impostareschemaTables: { persons: "all" }nelle opzioni del backend ripristina la descrizione completa. Vedi Endpoint. - I nomi delle relazioni sono esatti, e le chiavi esterne big-integer sono numeri (sezione 131).
- La cronologia viene servita mascherata (sezione 132).
- I nomi dei tool MCP e il payload delle view cambiano insieme per il connettore hosted e i runtime che esso raggiunge (sezione 122).
- Restrizioni intenzionali. I timestamp di audit (colonne
.onCreateNow()/.onUpdateNow()) sono nascosti per impostazione predefinita dalle colonne dell’elenco del pannello: un elenco migrato che mostravacreated_atperde quella colonna a meno che non si impostifields: { created_at: { hidden: false } }nel rispettivocustomizeTable. Il codemod rifiuta, indicandone il motivo, gli array JSON di tipo tupla, unvector/binary/referenceall’interno di una map,databaseIdsu una collection Postgres,isId: "cuid", una relazione con soloisIdedisableDefaultPolicies: truein assenza di regole. Viene rifiutata una relazione a colonna singola verso una tabella con chiave composita (scrivila conrel.via()). I tag OpenAPI derivano dallo slug, non dal nome visualizzato.rebase schema introspectesclude le tabelle prive di chiave primaria spiegandone il motivo (un server che effettua l’introspezione del database continua comunque a servirle). Una vista semplice che dichiararolesgenera un errore di compilazione; il codemod la rimuove aggiungendo una nota. - Cosa i progetti reali hanno comunque dovuto modificare manualmente — requisiti minimi della toolchain,
({ entity })nel codice admin, include di una relazione rinominata, oggetti collection modificati a runtime, chiamate SDK su ricevitori non tipizzati: Cosa i progetti hanno modificato manualmente. - Ripristino su un altro cluster. Il timbro delle policy di admin predefinite calcola l’hash degli OID dei ruoli; pertanto, dopo un dump o un ripristino point-in-time su un cluster diverso, il primo
db pusho avvio ricrea quelle policy una tantum, con gli stessi nomi e lo stesso SQL.
La terminologia
Sezione intitolata “La terminologia”| Prima | Ora | Dove “collection” rimane |
|---|---|---|
una collection in config/collections/ |
una tabella (table) in backend/schema/ (defineTable) |
— |
properties |
columns (col.*) e relations (rel.*) |
— |
securityRules, defaultSecurityRules |
rls (obbligatorio), defaultRls |
— |
callbacks, Property.callbacks |
hooks, il .transform() di una colonna |
— |
il blocco admin |
customizeTable in frontend/src/cms/ |
— |
data.collection(slug) |
data.table(slug) |
— |
| ciò che il pannello admin disegna | una collection: una tabella per come mostrata dal pannello, o una collection Firestore | il CMS: CollectionPanel, il Collection Editor, externalCollections |
108. Le tabelle in backend/schema sostituiscono config/collections — esegui prima il codemod
Sezione intitolata “108. Le tabelle in backend/schema sostituiscono config/collections — esegui prima il codemod”A chi si applica: a qualsiasi progetto con una cartella config/collections/.
Cosa è cambiato: il backend legge esclusivamente backend/schema/index.ts e i risultati esportati da defineTable, defineAuthTable e defineView. I file defineCollection non vengono letti da nulla: il runtime, ogni comando CLI e la validazione di rebase.json rifiutano un progetto che contenga ancora config/collections, indicando il comando sottostante. rls è obbligatorio su ogni tabella — un elenco di regole, "admin-only", o "inherit" per il defaultRls esportato dall’index — e disableDefaultPolicies diventa defaultPolicies: false.
Cosa fare:
rebase migrate collections-to-tables # o --dry-run primaScrive una tabella per ciascuna collection, rendendo esplicita ogni colonna fisica nella sua posizione originale (in modo che la colonna chiave di un belongsTo sia scritta chiaramente), l’index con defaultRls ricavato da defaultSecurityRules, un customizeTable per ogni collection la cui presentazione differiva da quella predefinita, e i file defineFirestoreCollection per le collection Firestore. I callback di una collection diventano gli hooks della tabella e i .transform() delle sue colonne; i callbacks globali esportati da config/index.ts richiedono un passaggio manuale (sezione 109). Successivamente rilegge il risultato tramite la nuova pipeline: DDL, policy, ricerca, vector, trigger, viste e lo schema Drizzle devono risultare identici byte per byte a quanto generato dalle collection, altrimenti ogni file viene ripristinato e l’esecuzione termina con codice 1 mostrando il diff.
Gestisce inoltre ciò che in precedenza richiedeva interventi manuali:
- I callback creati da un helper (
callbacks: softDeleteCallbacks(...), o un oggetto callback importato) diventanohooks:con la medesima espressione, e le funzioni dell’helper vengono convertite nelle proprietà degli hook di tabella nel punto in cui sono scritte (il codemod segue le importazioni relative, iconst, le letture di proprietà e i singolireturn). Quando non riesce a seguire l’helper, un passaggio indica gli hook da verificare. - Una funzione
storagePathviene migrata dividendosi in due parti: la funzione diventa lostorage.pathdella personalizzazione, così che il pannello continui a scegliere la destinazione del caricamento, mentre il templatepathdella colonna assume la forma delle chiavi restituite — il testo statico della sua template literal con ogni${…}sostituito da{path}(`${owner}/cv`→{path}/cv). Il server ora applicamaxByteseacceptdella colonna a qualsiasi caricamento la cui chiave corrisponda a quel template, non solo a quelli che specificano la colonna, rendendo i limiti più rigorosi rispetto a 0.30. Una funzione il cui risultato non contiene testo statico viene rifiutata: assegnagliene prima uno. - Un
policy.existsIn({ collection })di 0.30 mantiene la sua tabella, eauth: { collection: usersCollection }in un entry point di backend personalizzato viene rimosso (la tabella dichiarata condefineAuthTableè la tabella auth). L’opzione di avviocollectionsdiventaschemaDir. - Un generatore
dynamicPropsrestituisce una personalizzazione di campo con chiavi piatte in 0.31 ({ readOnly: true }, non{ admin: { readOnly: true } }). Il codemod riscrive i generatori i cui ritorni sono oggetti letterali, inline o in un modulo condiviso, ed elenca gli altri. - Le opzioni di presentazione estese da un singolo oggetto condiviso vengono riportate nella personalizzazione (
….dynamicProps); le presentazioni calcolate da una funzione wrapper generano un passaggio di verifica, non un rifiuto del progetto. Il percorso di un componente viene risolto rispetto al modulo che lo ha scritto, e un valore calcolato al caricamento diconfig/(new Date(),Date.now(), una lettura d’ambiente) viene mantenuto come espressione, senza venire congelato al valore dell’esecuzione. - Le collection Firestore generate da una funzione (un
getAllFirestoreCollections()esteso dall’app nel pannello) vengono convertite indefineFirestoreCollectionuna ad una dove il file di una collection contiene il relativo letterale; un passaggio per generatore elenca le restanti e la struttura da scrivere, mentre un altro elenca i riferimenti scritti fuori da un letterale convertito, che riporterebbero ancorapath. - Le importazioni di
config/tramite alias di percorso (una vocepathsdi tsconfig, unresolve.aliasdi Vite) vengono riscritte o elencate come quelle relative, e unostorageAuthorizeriesportato daconfig/index.tsviene trasferito inbackend/storage.ts. - Una relazione rinominata in
<key>Relationconserva etichetta, colonna di elenco e titolo: la personalizzazione usa la nuova chiave. Il codice che la include non viene aggiornato automaticamente (cosa modificare).
Ciò che non può essere convertito esattamente viene rifiutato indicando file e riga, senza scrivere alcun file: una collection creata invocando una funzione, uno spread o un accessor non analizzabile, un engine diverso da Postgres o Firestore, un file di output preesistente con contenuti differenti (spostalo altrove, o usa --force). Viene rifiutato anche un albero git con modifiche non committate o un progetto non tracciato con git, per garantire che la migrazione sia un singolo diff revisionabile. L’opzione --json stampa il report completo per script o agent. Consulta rebase migrate e Tabelle.
Le tabelle generate definiscono le proprie colonne secondo la sintassi di pg-core di Drizzle — col.varchar({ length: 160 }), col.timestamp({ withTimezone: true }), col.text().array(), pgEnum(...), .default(sql`…`), .generatedByDefaultAsIdentity() — quindi il loro output non necessita di ulteriori modifiche; consulta Colonne. Una tabella scritta manualmente per una pre-release di 0.31 usando la sintassi precedente (col.timestamptz(), col.varchar(160), col.array(col.text()), col.enum(values, { name }), .defaultSql(), .identity(), .column("…")) non compila più: lo script tooling/scripts/drizzle-sweep.mts nel repository di Rebase la converte, riscrivendo solo le catene di builder, e con --verify attesta che ogni tabella convertita compili nel medesimo descrittore (npx tsx drizzle-sweep.mts --verify backend/schema).
Il passaggio sdk-calls successivo riscrive anche i sorgenti delle regole: existsIn({ collection }) e membership: { collection } diventano table (sezione 123); --skip-sdk-calls salta anche questo. I passaggi rimanenti vengono stampati come istruzioni manuali numerate; se il progetto include agent skill installate, l’ultima istruzione è il comando rebase skills install per aggiornarle (sezione 128). Eseguire semplicemente rebase migrate mostra l’aiuto per entrambi i sottocomandi.
109. Non esiste più il pacchetto config
Sezione intitolata “109. Non esiste più il pacchetto config”A chi si applica: a tutti i progetti — config/ costituiva un workspace a sé stante.
La versione 0.31 smette di leggere config/collections, ma non vieta la presenza della cartella config/. Il codemod rimuove ciò che Rebase leggeva — i file delle collection e i collegamenti spostati in backend/ (resources.ts, storage.ts, generated/register.ts, e le relative riesportazioni in config/index.ts) — lasciando i tuoi moduli personali in config/ nella loro posizione, importabili come prima: config/ rimane un pacchetto del workspace e il backend compila ancora ../config/**/*. Vengono riscritte solo le importazioni degli elementi rimossi: un file di collection importato dal codice di backend punterà al modulo della tabella (un passaggio elenca gli utilizzi che lo leggono come oggetto); importato dal frontend, diventa un’importazione di tipo della tabella se usato solo come tipo, oppure genera un passaggio che specifica la personalizzazione; un helper all’interno di config/collections viene copiato a fianco del codice che lo richiede.
Cosa è cambiato: gli elementi situati accanto alle collection vengono spostati in backend/:
| Prima | Ora |
|---|---|
config/resources.ts |
backend/resources.ts |
config/storage.ts, storageAuthorize da config/index.ts |
backend/storage.ts |
callbacks esportati da config/index.ts |
hooks esportati da backend/hooks.ts (TableHooks: table per collection, values per row) |
config/generated/register.ts |
backend/generated/register.ts |
rebase.json config, usersCollection |
tables (default backend/schema); la tabella di autenticazione è quella dichiarata con defineAuthTable |
Il runtime legge storageAuthorize e hooks e nient’altro da questi moduli; qualsiasi altra esportazione viene segnalata all’avvio. Il frontend importa backend/** esclusivamente come tipi — pnpm check:frontend-backend-imports impedisce l’importazione di valori, che includerebbe codice server nel bundle per il browser.
Cosa fare: il codemod sposta resources.ts, storage.ts e la registrazione, e aggiorna rebase.json, package.json, pnpm-workspace.yaml e backend/tsconfig.json. La migrazione dei callbacks globali è indicata come passaggio manuale: spostali manualmente in backend/hooks.ts e aggiungi hooks.ts alla voce include di backend/tsconfig.json affinché tsc lo verifichi. Quindi esegui il comando git rm mostrato: git rm -r config/collections …, o git rm -r config se non rimane nient’altro di personalizzato.
110. Le opzioni di avvio e gli hook fanno riferimento alle tabelle
Sezione intitolata “110. Le opzioni di avvio e gli hook fanno riferimento alle tabelle”A chi si applica: a chi avvia manualmente il backend (initializeRebaseBackend, createRebaseBackend) e al codice che registra hook dopo l’avvio.
Cosa è cambiato:
| Prima | Ora |
|---|---|
collections, collectionsDir |
tables, defaultRls, schemaDir |
callbacks |
hooks |
auth.collection |
rimosso: si usa defineAuthTable in tables |
backend.setCollectionCallbacks(slug, cb) |
backend.setTableHooks(slug, hooks) |
proprietà degli hook collection, row |
table (il descrittore), values |
composeCallbacks |
composeTableHooks da @rebasepro/common |
openRebase({ collections, callbacks }) |
openRebase({ tables, hooks }), tables da compileSchema([...]) |
OpenedRebase.collections; la variabile collections in rebase console |
.tables; tables |
await initializeRebaseBackend({ app, server, collectionsDir: "./config/collections", callbacks });await initializeRebaseBackend({ app, server, schemaDir: path.resolve(__dirname, "../schema"), hooks });Gli hook associati a un oggetto collection passato direttamente nel punto di chiamata non vengono più eseguiti: il driver esegue gli hook delle tabelle che serve, pertanto registrali con setTableHooks.
Cosa fare: rebase migrate sdk-calls riscrive setCollectionCallbacks, adatta le proprietà degli hook ed elenca ogni oggetto di opzioni del backend da aggiornare a mano. Gli script che aprono i dati devono compilare le relative tabelle:
const rebase = await openRebase({ databaseUrl, collections, callbacks });const rebase = await openRebase({ databaseUrl, tables: compileSchema([products, orders]), hooks });Vedi Script, Panoramica del backend e Hook globali.
111. Il pannello di amministrazione renderizza le tabelle fornite dal server
Sezione intitolata “111. Il pannello di amministrazione renderizza le tabelle fornite dal server”A chi si applica: a ogni frontend che monta <RebaseCMS>.
Cosa è cambiato: <RebaseCMS collections> è stato rimosso. Il pannello mostra tutte le tabelle fornite dal backend tramite GET /api/schema/tables, senza richiedere un file per ciascuna tabella, seguite da externalCollections (Firestore). La prop tableCustomizations accetta gli oggetti customizeTable definiti in frontend/src/cms/. Il plugin Vite per le collection e virtual:rebase-collections sono stati rimossi. CollectionsProvider riceve i medesimi tre input (tableCustomizations, externalCollections, tables).
import { collections } from "virtual:rebase-collections";<RebaseCMS collections={collections}/>import { postsCms } from "./cms/posts";<RebaseCMS tableCustomizations={[postsCms]}/>Cosa fare: il codemod genera frontend/src/cms/index.ts, che esporta tableCustomizations (ed externalCollections), e lo collega direttamente nel file App.tsx dello scaffold; se App.tsx non viene riconosciuto, la rimozione del plugin in vite.config.ts e la dichiarazione del modulo virtuale vengono indicate tra i passaggi manuali. Consulta Personalizzare una tabella.
112. Bundle in formato 3; i bundle in formato 2 vengono rifiutati
Sezione intitolata “112. Bundle in formato 3; i bundle in formato 2 vengono rifiutati”A chi si applica: a qualsiasi deploy di un bundle compilato — in self-hosting con l’immagine di runtime, o su Rebase Cloud.
Cosa è cambiato: lo schema del bundle è definito in entry.tables, accanto a entry.resources, entry.storage ed entry.hooks; bundleFormat passa a 3 e runtime contract a 2. Un bundle in formato 1 o 2 include config/collections, che un runtime 0.31 non è in grado di leggere; pertanto il runtime ne rifiuta l’avvio suggerendo il codemod nel messaggio, anziché tentare l’introspezione del database esponendo un’API differente.
Cosa fare: migra il codice sorgente, quindi esegui rebase build ed effettua il deploy. Su Rebase Cloud, il deploy del repository migrato attiverà automaticamente la ricompilazione. Consulta Runtime e bundle.
Su Rebase Cloud, un progetto fermo a 0.30 continua a funzionare ma non può effettuare nuovi deploy. La piattaforma continua a servire il bundle esistente e gli aggiornamenti del runtime si interrompono (come segnalato dalla console), ma accetta esclusivamente il formato 3: un deploy eseguito con la CLI 0.30 carica l’intero bundle ma viene poi rifiutato con l’errore BUNDLE_FORMAT_TOO_OLD. La procedura di aggiornamento prevede gli stessi tre comandi per qualsiasi progetto:
pnpm exec rebase upgrade --to latestrebase migrate collections-to-tablesrebase cloud deployUna versione della CLI successiva alla 0.32.0 blocca l’operazione in anticipo, prima di compilare o caricare elementi: l’esecuzione di rebase build e rebase cloud deploy su un progetto le cui tabelle risiedono ancora in config/collections si interrompe indicando il codemod, un --bundle-dir contenente un bundle in formato 2 viene respinto con “Nothing was uploaded”, e rebase upgrade indica il codemod come passaggio successivo anziché rebase build. (Il comando rebase upgrade della 0.30 termina ancora suggerendo “Run rebase build”, ma è proprio la build indicata a bloccarsi.)
113. La versione dello schema viene calcolata dalle tabelle (v2:)
Sezione intitolata “113. La versione dello schema viene calcolata dalle tabelle (v2:)”A chi si applica: a ogni database configurato con un runtime precedente a 0.31 e a ogni SDK generato.
Cosa è cambiato: la versione dello schema calcola l’hash dei descrittori compilati delle tabelle e inizia con il prefisso v2:. Un database contrassegnato con v1: segnala il cambio di modello una sola volta — tramite i log di avvio e rebase doctor, che indicano come aggiornare la marcatura — e ciascun SDK generato viene segnalato come obsoleto una tantum.
Cosa fare: effettua il provisioning una volta con il nuovo runtime: avvia il processo proprietario dello schema, oppure esegui rebase db push. Se REBASE_REQUIRE_SCHEMA_MATCH=true, aggiorna la marcatura prima di riavviare gli altri processi. Rigenera l’SDK.
114. I codici di errore fanno riferimento alle tabelle
Sezione intitolata “114. I codici di errore fanno riferimento alle tabelle”A chi si applica: al codice che gestisce la logica condizionale in base alla proprietà code dell’errore.
Cosa è cambiato:
| Prima | Ora |
|---|---|
NO_COLLECTIONS (404) |
NO_TABLES |
COLLECTION_READ_ONLY (405) |
TABLE_READ_ONLY |
UNKNOWN_COLLECTION (SDK) |
UNKNOWN_TABLE |
INVALID_COLLECTION_PATH (SDK) |
INVALID_TABLE_PATH |
Cosa fare: rebase migrate sdk-calls riscrive le stringhe letterali. Consulta Errori.
115. L’SDK fa riferimento a una tabella: data.table(slug)
Sezione intitolata “115. L’SDK fa riferimento a una tabella: data.table(slug)”A chi si applica: a qualsiasi client, funzione, cron, hook e script che fa riferimento a una tabella tramite il suo slug, o che passa il dizionario generato.
Cosa è cambiato:
| Prima | Ora |
|---|---|
data.collection(slug) |
data.table(slug) |
createRebaseClient({ collections: collectionsDictionary }) |
createRebaseClient({ tables: tablesDictionary }) |
CollectionName, CollectionsDictionary generati |
TableName, TablesDictionary |
batch { op, collection } (SDK e POST /api/data/_batch) |
{ op, table } |
CollectionClient, SDKCollectionClient, CollectionAccessor, CollectionTrashAccessor |
TableClient, SDKTableClient, TableAccessor, TableTrashAccessor |
opzioni offline maxCachedRowsPerCollection, maxCachedQueriesPerCollection |
…PerTable |
accessor riservato <name>Collection; collectionCollection |
<name>Table; la tabella collection diventa collection |
const { data } = await client.data.collection("posts").find();const { data } = await client.data.table("posts").find();Gli accessor tipizzati (client.data.posts) rimangono invariati.
Cosa fare: il codemod esegue rebase migrate sdk-calls sul codice — eseguilo singolarmente se il progetto è già migrato — quindi lancia rebase generate-sdk. Una chiamata .collection( il cui ricevitore non appartiene all’SDK viene lasciata inalterata ed evidenziata nell’elenco. Consulta Typed SDK.
116. Flag della CLI: --schema-dir, non --collections
Sezione intitolata “116. Flag della CLI: --schema-dir, non --collections”A chi si applica: a script e step di CI che richiamano la CLI indicando il percorso dello schema.
Cosa è cambiato: --collections / -c vengono rifiutati in tutti i comandi che leggono lo schema, indicando il codemod nel messaggio (generate-sdk ignora un eventuale --collections-dir residuo); --schema-dir specifica una cartella di schema alternativa a backend/schema. rebase schema introspect scrive i file defineTable all’interno di backend/schema/ — l’opzione --output è stata rimossa. La variabile REBASE_STRICT_COLLECTION_CONFIG non viene più considerata: uno schema che non compila impedisce sempre l’avvio.
Cosa fare: aggiorna i flag utilizzati. Consulta CLI e Generazione dello schema.
117. Lo schema editor modifica backend/schema con TablePatch
Sezione intitolata “117. Lo schema editor modifica backend/schema con TablePatch”A chi si applica: al codice che invoca le route dello schema-editor o del live-schema, e ai deployment in cui sono impostate le variabili per la modifica a caldo.
Cosa è cambiato: /api/admin/schema-editor/collection/save, collection/delete, property/save e property/delete sono stati rimossi. L’editor espone GET /tables, POST /preview e POST /apply, mentre gli endpoint /plan e /apply per le modifiche a caldo dello schema accettano { patches: TablePatch[] } anziché una collection o una sua patch. La variabile REBASE_LIVE_SCHEMA_COLLECTIONS_PATH viene rifiutata all’avvio: il nuovo nome è REBASE_LIVE_SCHEMA_PATH (default backend/schema), e liveSchema.repository.collectionsPath diventa schemaPath. La configurazione della visualizzazione non rientra più nelle modifiche allo schema: viene memorizzata come preferenze UI (/api/admin/ui-config). Un tentativo di modifica applicato a un file cambiato su disco dopo la preparazione dell’operazione (salvataggio da IDE, altri processi concorrenti) restituisce 409 SCHEMA_EDIT_STALE_FILE senza scrivere nulla; in precedenza rispondeva con 400 SCHEMA_EDIT_REFUSED.
Cosa fare: rinomina la variabile di ambiente; aggiorna i client delle route in modo che inviino modifiche di tipo TablePatch, gestendo il ricaricamento in caso di errore SCHEMA_EDIT_STALE_FILE. Vedi Modifica dello schema a caldo.
118. Lo slot di un componente accetta direttamente il componente
Sezione intitolata “118. Lo slot di un componente accetta direttamente il componente”A chi si applica: alle personalizzazioni che specificavano un componente React tramite stringa di percorso o con thunk lazy () => import(…).
Cosa è cambiato: le proprietà Field / Preview / Filter di un campo, le Actions di una collection, entityViews[].Builder, collectionViews[].Builder, formView.Builder e gli override dei componenti accettano direttamente il componente stesso. Sono stati rimossi ComponentRef, ComponentLike, LazyComponentRef e isLazyComponentRef (@rebasepro/types), asComponentRef e asReactComponent (@rebasepro/cms-types), nonché resolveComponentRef / useResolvedComponent (@rebasepro/app). customizeTable rifiuta stringhe o thunk mostrando il messaggio “imported by value”.
Cosa fare: importa il componente nel file situato in frontend/src/cms/ e passalo direttamente. Consulta Campi personalizzati.
Il codemod esegue questa operazione per ogni percorso specificato come stringa, segnalando ciascun intervento: a differenza dei percorsi a stringa, un componente importato viene verificato a livello di tipi rispetto al proprio slot. Un componente Preview che definisce customProps?: MyProps genererà un errore di compilazione con il tsc del frontend: lo slot passa customProps come unknown, poiché non vi è correlazione vincolante tra le customProps di un campo e il componente che le legge. Dichiara customProps?: unknown e applica il type narrowing all’interno del componente.
119. Le preferenze del pannello sono preferenze UI
Sezione intitolata “119. Le preferenze del pannello sono preferenze UI”A chi si applica: al codice che implementa UserConfigurationPersistence.
Cosa è cambiato: le regolazioni apportate dall’utente alle dimensioni o all’ordine delle colonne di una tabella sono gestite come differenze in UiTablePreferences: getTablePreferences / saveTablePreferences sostituiscono getCollectionConfig / onCollectionModified, e il tipo parziale di configurazione della collection precedentemente accettato è stato rimosso. Il local store del browser le memorizza con la chiave table_preferences::<slug>, ignorando i dati salvati dai pannelli precedenti; pertanto, le larghezze delle colonne e le modalità di visualizzazione di ciascun utente vengono reimpostate una tantum. La proprietà userSelect sui campi è stata rimossa: per consentire la selezione degli utenti si usa una colonna .userId().
Anche il bridge di Studio è stato allineato: StudioSchemaEditing.updateCollection diventa applyTablePatches(slug, patches), e l’editor di collection invia { patches } allo schema editor.
Cosa fare: aggiorna le implementazioni di persistenza personalizzate per implementare i due nuovi metodi, e adatta eventuali implementazioni di StudioSchemaEditing per utilizzare applyTablePatches.
120. MongoDB è deprecato e non più supportato
Sezione intitolata “120. MongoDB è deprecato e non più supportato”A chi si applica: ai progetti che utilizzano @rebasepro/server-mongo o che specificano database(…, { engine: "mongodb" }).
Cosa è cambiato: il pacchetto è stato rimosso, unitamente ai tipi delle collection Mongo e all’intero modello a oggetti per Mongo. Postgres rappresenta l’unico engine di backend supportato: qualsiasi configurazione di trasporto server basata su un engine differente impedisce l’avvio del sistema, esplicitando il nome dell’engine non supportato.
Cosa fare: migra i dati su Postgres. Non è disponibile un percorso di migrazione automatizzato all’interno di Rebase.
121. Le collection Firestore risiedono nel frontend
Sezione intitolata “121. Le collection Firestore risiedono nel frontend”A chi si applica: ai progetti ibridi configurati con collection aventi engine: "firestore".
Cosa è cambiato: una collection Firestore costituisce ora una sorgente CMS accessibile direttamente dal browser: si definisce tramite defineFirestoreCollection dal pacchetto @rebasepro/firebase, all’interno di frontend/src/cms/, e viene passata alla prop <RebaseCMS externalCollections>. I riferimenti tra un documento Firestore e una tabella Postgres vengono memorizzati come ID della risorsa di destinazione; un riferimento Firestore il cui path coincide con lo slug di una tabella Postgres punterà a quest’ultima.
Cosa fare: il codemod genera i relativi file defineFirestoreCollection. Configura i riferimenti verso una collection Firestore utilizzando lo slug di tale collection. Vedi Firebase.
122. I tool MCP prendono il nome dalle tabelle
Sezione intitolata “122. I tool MCP prendono il nome dalle tabelle”A chi si applica: a prompt, script e allow-list che specificano tool MCP.
Cosa è cambiato: endpoint remoto /mcp: list_collections, describe_collection, query_collection, show_collection, count_documents, aggregate_documents, get_document, create_document, update_document, delete_document diventano list_tables, describe_table, query_table, show_table, count_rows, aggregate_rows, get_row, create_row, update_row, delete_row; il parametro collection è sostituito da table, e show_app / save_app accettano tables. Server locale: list_documents → query_table, get_document → get_row, create_document → create_row, update_document → update_row, delete_document → delete_row; rebase_schema_plan accetta patches; i path delle risorse diventano rebase://tables/{name}. Il payload delle viste delle MCP App passa alla versione 3: descrittori di tabella oscurati in base ai permessi del chiamante, autorizzazioni granulari per singola tabella e preferenze UI dell’utente in preferences (file, workspace, user; le API key non dispongono del livello user), con blocchi e seed che fanno riferimento a table. La vista collection-table è stata rimossa. list_tables non include title; describe_table integra primaryKey, relations, le regole rls del chiamante, title e presentation.
Cosa fare: aggiorna i riferimenti ai nomi. La vista e il server devono condividere la medesima versione del payload: il connettore hosted e i runtime a cui si collega vanno aggiornati contestualmente, e le viste MCP realizzate nel progetto devono essere ricompilate con i pacchetti 0.31. Vedi Reference dei tool MCP e Remote MCP.
123. Il lessico delle regole di sicurezza usa table
Sezione intitolata “123. Il lessico delle regole di sicurezza usa table”A chi si applica: alle regole che impiegano policy.existsIn o contesti di tenancy basati su membership, e alle regole che associano access ad altre clausole.
Cosa è cambiato: policy.existsIn({ collection, where }) diventa existsIn({ table, where }), e tenant.from.membership.collection diventa membership.table; i nomi delle policy restano inalterati. Quattro configurazioni di regole producono ora concessioni differenti, due delle quali più estese (vedi la tabella sopra): la forma semplice { access: "authenticated" }, che prima non concedeva alcun accesso, consente ora le operazioni a qualsiasi utente autenticato, e le tabelle ponte (junction) collegate ottengono le corrispondenti policy di scrittura per gli archi. Vengono rifiutate le regole che uniscono clausole non ammesse dal tipo SecurityRule, o che indicano valori non validi per access, mode, operation o roles.
Cosa fare: il codemod rinomina le chiavi, segnala con file e riga le regole non valide e compila l’elenco di quelle il cui comportamento cambia nella sezione “Review before deploying”. Per ciascuna di esse: confermala, imposta access: "registered" (per limitarla agli utenti autenticati dotati di account), o rimuovila. Successivamente analizza l’output di rebase db push --dry-run e rebase doctor --policies a fronte del tuo database.
124. Studio legge le tabelle direttamente dal server
Sezione intitolata “124. Studio legge le tabelle direttamente dal server”A chi si applica: a istanze di Studio collegate a un backend precedente a 0.31 e agli script eseguiti nella console JS di Studio.
Cosa è cambiato: tutti gli strumenti che elaborano lo schema interrogano GET /api/schema/tables; se connessi a un runtime privo di tale endpoint mostrano un avviso di aggiornamento. La vista delle dichiarazioni nell’editor RLS riflette quanto compilato dal server. Gli script della console JS ricevono la proprietà context.tables (in precedenza denominata context.collections).
Cosa fare: aggiorna il runtime contestualmente al pannello. Vedi Studio.
125. rls-check --format agent usa la proprietà rls
Sezione intitolata “125. rls-check --format agent usa la proprietà rls”A chi si applica: a utility o processi che consumano l’output di rls-check --format agent.
Cosa è cambiato: remediation.rebase.securityRules è ora remediation.rebase.rls, lo snippet generato assume la forma defineTable(…, { rls }), e la versione del formato del documento passa a 2. L’output con flag --json resta invariato. Vedi rls-check.
Cosa fare: adatta i parser per leggere la nuova chiave.
126. @rebasepro/plugin-review: reviewRls
Sezione intitolata “126. @rebasepro/plugin-review: reviewRls”A chi si applica: ai progetti che integrano il plugin review.
Cosa è cambiato: reviewSecurityRules(slug, review) diventa reviewRls(slug, review), da applicare tramite spread all’interno di rls della tabella; findReviewConfigProblems e assertReviewConfig ricevono i descrittori di tabella.
Cosa fare: rinomina la chiamata e fornisci come argomento services.tables() o compileTables(…).
127. @rebasepro/codegen elabora descrittori
Sezione intitolata “127. @rebasepro/codegen elabora descrittori”A chi si applica: al codice che richiama direttamente il generatore.
Cosa è cambiato: generateTypedefs(tables) e generateSDK(tables, options) accettano TableDescriptor[] — il tipo restituito da compileTables ed esposto da GET /api/schema/tables — invece delle collection.
Cosa fare: compila le definizioni prima dell’invocazione, oppure ricorri al comando rebase generate-sdk.
128. L’agent skill rebase-collections diventa rebase-tables
Sezione intitolata “128. L’agent skill rebase-collections diventa rebase-tables”A chi si applica: ai progetti con agent skill installate, e a prompt o file di istruzioni che menzionano il nome della skill.
Cosa è cambiato: la skill preposta alla gestione del modello dati è ora rebase-tables: copre la dichiarazione di tabelle, colonne, relazioni, rls, hook e lo strato CMS correlato. Il comando rebase skills install provvede a rimuovere la precedente istanza di rebase-collections (anche da installazioni antecedenti alla presenza del manifest delle skill), preservando eventuali cartelle con lo stesso nome create manualmente.
Cosa fare: esegui rebase skills install al termine dell’aggiornamento. Questa indicazione è inclusa anche nei passaggi mostrati da rebase migrate collections-to-tables. Modifica il nome della skill nei file di istruzioni in cui è citata. Consulta Agent Skills.
129. useJsonCollectionsConfigController è stato rimosso
Sezione intitolata “129. useJsonCollectionsConfigController è stato rimosso”A chi si applica: ai progetti che persistevano le definizioni delle collection come JSON tramite @rebasepro/cms.
Cosa è cambiato: useJsonCollectionsConfigController è stato eliminato assieme al rispettivo tipo di opzioni e alla sottostante classe di archiviazione JSON. La definizione strutturale di una tabella risiede in backend/schema, mentre la relativa rappresentazione per il pannello è memorizzata nelle preferenze UI: frontend/src/cms/ui-config.json in ambiente di sviluppo, e la tabella rebase.ui_preferences in ambienti di produzione.
Cosa fare: dichiara le tabelle tramite defineTable (rebase migrate collections-to-tables le estrae a partire dalle definizioni di collection preesistenti), e passa l’uiConfig dello scaffold al componente <RebaseCMS>. Consulta Personalizzare una tabella.
130. rebase build impedisce la compilazione di frontend privi di rebaseBackendGuard()
Sezione intitolata “130. rebase build impedisce la compilazione di frontend privi di rebaseBackendGuard()”A chi si applica: a qualsiasi progetto provvisto di interfaccia frontend.
Cosa è cambiato: il frontend è abilitato a importare risorse da backend/ esclusivamente sotto forma di tipi.
Un’importazione per valore esporrebbe logica server — hook o credenziali riservate in essi referenziate —
all’interno del bundle destinato al browser. Il plugin rebaseBackendGuard() fornito da @rebasepro/app/vitePlugin interrompe l’esecuzione di vite build e vite dev se rileva la risoluzione di un modulo frontend verso backend/, indicando importer, importazione e file coinvolto, tenendo conto di alias, tsconfig paths, risoluzioni package o assolute, glob, ?raw, riesportazioni e import dinamici. Il comando rebase build, così come la fase di build frontend orchestrata da rebase cloud deploy, bloccano l’operazione se la configurazione Vite non lo include; rebase dev emette un warning; rebase verify segnala l’errore cms-backend-guard-missing.
Cosa fare: il codemod lo integra nel file frontend/vite.config.ts dello scaffold e fornisce le istruzioni per qualsiasi altra configurazione:
import { rebaseBackendGuard } from "@rebasepro/app/vitePlugin";
export default defineConfig({ plugins: [react()], plugins: [react(), rebaseBackendGuard()],});Successivamente, modifica qualsiasi importazione per valore da backend/ in import type.
131. I dati inviati sul canale di rete rispettano il tipo della colonna
Sezione intitolata “131. I dati inviati sul canale di rete rispettano il tipo della colonna”A chi si applica: ai client che consumano foreign key o specificano relazioni, e alle scritture che inviano colonne generate o oggetti JSON parziali.
Cosa è cambiato: i valori vengono elaborati dal codec della colonna in uscita e validati dalle sue regole in entrata.
-
Una colonna foreign-key di tipo
bigintonumericderivata da una relazione, restituita come stringa da Postgres, viene serializzata come numero nei contesti REST, SDK e pannello di amministrazione. Le chiavi dichiarate come numeriche adottavano già questa convenzione. -
Gli elementi di un array nativo sono serializzati in conformità al loro tipo scalare, nelle chiamate REST, nell’SDK, via socket e a livello di driver:
Colonna 0.30 restituiva 0.31 restituisce timestamptz[]["2026-01-02 11:00:00+01"]["2026-01-02T10:00:00.000Z"]numeric[](driver inizializzato senza l’impostazione numerica a tempo di avvio: test, script)["1.50", "2.25"][1.5, 2.25]bigint[]contenente un elemento null[1, 0, 3][1, null, 3]date[],timestamptz[]o array di enum contenente un elemento null["2026-01-02", "NULL"]["2026-01-02", null]Le tipologie
date[],time[],text[],uuid[],boolean[],integer[]edouble precision[]mantengono l’output precedente. I dati salvati sul database non subiscono variazioni: la rilettura e il successivo salvataggio di una riga preservano il medesimo array. -
Una relazione indicata in
include, in un filtro o in un ordinamento deve corrispondere al suo nome esatto. Non sono più previsti tentativi di fallback con lo slug o la notazione snake_case. -
La scrittura su colonne generate genera un errore ed esse vengono omesse dallo schema di input OpenAPI.
-
È imposto il rispetto dei campi obbligatori negli oggetti JSON; i valori di
$ince gli elementi di array su colonne intere devono essere numeri interi.
Cosa fare: gestisci le chiavi esterne come valori numerici nei punti in cui eseguivi confronti con stringhe, interpreta gli elementi di timestamptz[] secondo lo standard RFC 3339, gestisci gli elementi null negli array come null ed esprimi i nomi delle relazioni attenendoti alla dichiarazione della tabella (le chiavi specificate in relations). Cessa l’invio di valori destinati a colonne generate.
132. La cronologia viene restituita applicando la pipeline di lettura
Sezione intitolata “132. La cronologia viene restituita applicando la pipeline di lettura”A chi si applica: a chi legge gli snapshot storici e a chi sviluppa un DataDriver personalizzato.
Cosa è cambiato: le voci di cronologia vengono servite trattandole come operazioni di lettura: si applicano i controlli sui campi, seguiti dai meccanismi afterRead (globali, di tabella e di colonna). Le colonne mascherate da un hook o da un .transform({ afterRead }) risultano mascherate in tutti gli snapshot; una colonna non accessibile al richiedente viene omessa ed esclusa da changed_fields; le chiavi appartenenti a colonne eliminate vengono rimosse; il ripristino (revert) non valorizza mai colonne non leggibili dall’utente. Se un hook solleva un’eccezione su un vecchio snapshot, la richiesta fallisce. Poiché 0.30 restituiva i dati persistiti senza elaborazioni, è opportuno migrare i progetti che fanno uso congiunto di cronologia e hook di mascheramento.
Ciascuna voce rappresenta la riga esattamente come verrebbe restituita da GET /api/data/<table>/<id> senza parametri include: valori atomici e la chiave esterna per le relazioni belongsTo. Una voce registrata da una versione precedente secondo il view model dell’admin panel viene normalizzata e ripristinata nel formato standard di riga: i wrapper { "__type": "date", "value" } vengono risolti al solo valore, i riferimenti { "__type": "relation" } per relazioni dirette vengono convertiti nella chiave esterna sotto il nome proprio del campo, e qualsiasi altro ref viene convertito nella chiave della riga associata. La versione 0.30 esponeva tali ref non elaborati.
Un driver serve la cronologia implementando il metodo DataDriver.serveStoredRows(path, rows), eseguito all’interno della transazione in sola lettura del richiedente; in assenza di tale implementazione, gli endpoint di cronologia rispondono con 501, evitando l’esposizione di dati non mascherati.
Cosa fare: nessuna operazione se si impiega il driver Postgres ufficiale. Per i driver proprietari, implementare serveStoredRows. Consulta Cronologia.
133. Le esportazioni di @rebasepro/server fanno riferimento alle tabelle
Sezione intitolata “133. Le esportazioni di @rebasepro/server fanno riferimento alle tabelle”A chi si applica: a chi assembla un server importando i componenti interni di @rebasepro/server anziché usare initializeRebaseBackend / createRebaseBackend.
Cosa è cambiato:
| Prima | Ora |
|---|---|
new RestApiGenerator(collections, …) |
new RestApiGenerator(tables, …) (RestTables) |
mountOpenApiDocs({ collections }), createHistoryRoutes({ collections }) |
mountOpenApiDocs({ serverTables }), createHistoryRoutes({ tables }) |
versionProperty, buildCollection*Schema |
versionColumn, buildTable*Schema; i validatori e i moduli di supporto a conflitti ed ETag richiedono un TableDescriptor |
auth-collection-writes |
auth-table-writes: createUserThroughAuthTable, isAuthTable, prepareAuthTableUpdates, deletingAuthTableUsers |
opzione dell’adapter di autenticazione collectionAuthConfig |
authTableHooks (CompiledAuthHooks) |
McpRoutesConfig.getCollections |
getTables() |
assertUploadWithinPropertyLimits, readUploadPropertyContext |
assertUploadWithinColumnLimits, readUploadColumnContext (restituisce { table, column }); i dettagli del rifiuto specificano column |
provisionCollectionTables, provisionCollectionPolicies, collectionsStoredBy |
provisionTableSchema, provisionTablePolicies, tablesStoredBy |
handGlobalCallbacksTo, warnOnAuthCollectionDataCallbacks |
handGlobalHooksTo, warnOnAuthTableDataHooks |
SchemaEditingAdmin.planSchemaChange(collections, …) |
planSchemaChange(tables, …) con CompiledTable[]; EditedSchema.tables |
buildCollectionFromTableMetadata, IntrospectedCollection, IntrospectedRelation |
rimossi: una tabella introspezionata è un TableDescriptor |
createUserThroughAuthCollection; NestedWriteHop.parentCollection / .targetCollection; ContractRoutesConfig.collectionRegistry |
createUserThroughAuthTable; .parent / .target (descrittori); rimossi |
il caricatore di collection: CollectionConfigError, ConfigProblem, applyCollectionDefaults, CollectionDefaults e il tipo delle opzioni del validatore, accessModelFromCollections, loadBundleConfigExports, BundleConfigExports, unknownKeyPolicyFromEnv, UnknownKeyPolicy |
rimossi: compileSchema / loadBackendSchema caricano e validano backend/schema, e un’istanza di SchemaDefinitionError notifica ogni errore |
Cosa fare: adatta i nomi. Il comando rebase migrate sdk-calls rinomina automaticamente assertUploadWithinPropertyLimits e le costanti relative ai campi di upload (UPLOAD_COLLECTION_FIELD / UPLOAD_PROPERTY_FIELD → UPLOAD_TABLE_FIELD / UPLOAD_COLUMN_FIELD, mantenendo i valori invariati), e segnala con un passaggio manuale numerato ogni altra importazione o opzione di questa tabella.
134. Le esportazioni di @rebasepro/server-postgres fanno riferimento alle tabelle
Sezione intitolata “134. Le esportazioni di @rebasepro/server-postgres fanno riferimento alle tabelle”A chi si applica: al codice che istanzia direttamente il driver Postgres, incapsula l’adapter o consuma il planner dello schema.
Cosa è cambiato:
| Prima | Ora |
|---|---|
la classe PostgresCollectionRegistry, getTable(name), registerTable |
PostgresTableRegistry, getPgTable, registerPgTable |
openPostgresDriver(config, { collections }) |
openPostgresDriver(config, { tables }), tables provenienti da compileSchema; le chiamate al driver non accettano la prop collection (sezione 137) |
metodi di adapter / bootstrapper: ensureCollectionSchema, ensureCollectionPolicies, readCollectionsSchemaVersion, stampCollectionsSchemaVersion |
ensureTableSchema, ensureTablePolicies, readTablesSchemaVersion, stampTablesSchemaVersion, con argomenti di tipo CompiledTable[] |
serializePropertyToServer, parsePropertyFromServer |
serializeColumnToServer(value, column); parsePropertyFromServer è stato rimosso — la lettura dal driver produce la riga REST (sezione 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 (e i campi di log nel warning di boot drift) |
.slug, .key |
createStampKeys, sharedRelationName, isAuthCollection, lowerCompiledTables, buildCollectionIndexPlan |
rimossi |
La struttura JSON emessa dal planner mantiene le proprie chiavi: SchemaReconcileColumn.collection e i descrittori SchemaChange non subiscono variazioni.
Cosa fare: adatta i nomi. Un adapter wrapper che implementa BackendBootstrapper deve delegare le chiamate a ensureTableSchema e ensureTablePolicies. Consulta Integrare il driver Postgres.
135. @rebasepro/types e @rebasepro/common eliminano il modello collection dalla root
Sezione intitolata “135. @rebasepro/types e @rebasepro/common eliminano il modello collection dalla root”A chi si applica: al codice che importa tipi di collection o property, helper del pannello di amministrazione o utilità di trasformazione da @rebasepro/types o @rebasepro/common — campi custom, visualizzazioni custom, plugin, test con fixture basate su collection — e a driver custom che implementano il registry.
Cosa è cambiato: i pacchetti core rappresentano esclusivamente tabelle. Tutto ciò che definisce una collection per la renderizzazione nel pannello di amministrazione risiede ora in @rebasepro/cms-types:
- Tipi trasferiti da
@rebasepro/types:CollectionConfig,PostgresCollectionConfig,FirebaseCollectionConfig,AnyCollectionConfig, ogni…Property(StringProperty,NumberProperty,ArrayProperty, …) eProperties,CollectionCallbackse i relativi tipi per i parametri degli hook, i tipi di relazione supportati nella 0.30 e le loro variantiResolved…,CollectionIndex, i token colore (ColorScheme,ColorKey, …),FieldAccess,EnumValues. - Helper trasferiti da
@rebasepro/common: i generatori di policy per collection (policyToPostgres,compileRulePolicies,getEffectiveSecurityRules,getGeneratedPolicyNames, …),CollectionRegistry,resolveCollectionRelations,resolveRelation,getTableName,findRelation,rowToViewModel,resolvePrimaryKeys, la gestione di accesso per campo (effectiveAccess,canReadField,canWriteField),evaluateCondition,canEditEntity,resolveProperty,getDefaultValuesFor,getSubcollections,getCopyValues,enumToObjectEntries. La compilazione di regole da espressioni semplici avviene tramitecompilePolicyExpression(expr)da@rebasepro/common. composeCallbacksaggrega i callback di una collection ad uso del pannello ed è stato collocato in@rebasepro/cms-types;@rebasepro/servernon lo esporta più. La composizione degli hook di tabella per il backend richiedecomposeTableHooksda@rebasepro/common; il codemod segnala le importazioni backend dicomposeCallbackstramite uno step dedicato.defineCollectionè stato eliminato sia da@rebasepro/commonsia da@rebasepro/cms-types: le tabelle si definiscono condefineTableinbackend/schemae si personalizzano tramitecustomizeTableinfrontend/src/cms; per Firestore si ricorre adefineFirestoreCollectionda@rebasepro/firebase.- L’accessor del pannello admin e i suoi tipi:
Entity,EntityValues,TableAccessor,TableTrashAccessor,FindResponse,QueryBuilderInterface,RebaseDataeAuthStatesono stati rimossi da@rebasepro/types;buildRebaseData,wrapAsEntityData,buildRoutedRebaseData,EntityDataOptions,QueryBuilder,RelationRefecreateRelationRefsono stati rimossi da@rebasepro/common. Tutti questi vanno importati da@rebasepro/cms-types. Il livello di accesso dati dell’SDK —buildSdkData,createDriverTableRows,buildRoutedSdkData, presente in@rebasepro/common— restituisce le righe inalterate esattamente come in precedenza. EntityDataOptions.resolveCollectionè sostituito daprimaryKeysOf,viewModelOf,storedValuesOfeviewModelSourceOf; la funzionecollectionEntityDataOptions(resolveCollection, { resolveDataPath, resolveAccessor })in@rebasepro/cms-typespermette di costruirli.- Le utility di migrazione (
collectionsToTableDefs,collectionToTableDef,LiftNote,LiftResult,LiftOptions) sono state spostate in@rebasepro/common/migrate, insieme a una snapshot immutabile del modello a collection della 0.30 (tipiLegacy…) e adefineLegacyCollection. - Ulteriori rimozioni dai moduli kernel di root, ciascuna notificata dal codemod come operazione manuale: l’API per le patch delle collection in
@rebasepro/types(CollectionPatch,CollectionPatchOp,applyCollectionPatch,collectionPatchProblems,isCollectionPatch,nestCollectionPatchPaths→ convertiti inTablePatch), i metodi JSON per collection (diffCollections,diffJsonValues,toCollectionJson,RUNTIME_ONLY_COLLECTION_KEYS,runtimeOnlyKeyIn), i residui per MongoDBDocumentAdmin,isDocumentAdmine il capability flagsupportsDocumentAdmin, e le proprietàRebaseProjectContract.collectionSlugs/.collections/.generatedAt(/api/meta/contractrestituisce oratables); da@rebasepro/common,buildTenantSecurityRule→tenantSecurityRule,defaultPoliciesDisabled→tableDefaultPoliciesDisabled,restoresSoftDeletedRow→isSoftDeleteRestore,softDeleteFieldOf→softDeleteColumn,getJunctionConfigForRelation→resolveTableJunctions, mentreisRelationRequired,relationDeclaringProperty,requireCallbackCollectionnon prevedono sostituti (si legge direttamente ilTableDescriptor). - Il registry di un driver implementa l’interfaccia
TableRegistryInterface(invece diCollectionRegistryInterface):setGlobalHooks?esetTableHooks?prendono il posto digetGlobalCallbacks/setGlobalCallbacks?. Vengono rimossiglobalHooksAsCallbacks,resolveDriftCheckNameePENDING_TABLE_FEATURES.
Cosa fare: il comando rebase migrate sdk-calls (integrato in collections-to-tables) riallinea ciascuna importazione seguente al pacchetto di destinazione — integrandosi in eventuali importazioni preesistenti dello stesso pacchetto nel file, salvaguardando import type, type inline e alias as — e include il pacchetto tra le dipendenze del workspace package interessato; lancia pnpm install al termine. L’importazione di entità eliminate, le importazioni namespace (import * as), gli statement export *, gli import() dinamici o l’uso di require() su elementi migrati vengono segnalati come interventi manuali numerati. Se i test contengono fixture con strutture di collection letterali, associale ai tipi Legacy… e convertile usando @rebasepro/common/migrate.
Importazioni riposizionate
Sezione intitolata “Importazioni riposizionate”Tutti i simboli eliminati o trasferiti a un altro pacchetto in 0.31 sono consultabili in Importazioni spostate nella versione 0.31, assieme alle indicazioni di sostituzione per gli elementi rimossi. L’elenco è generato a partire dalla medesima matrice analizzata dal codemod, riflettendo esattamente le modifiche apportate da rebase migrate sdk-calls.
136. Il driver Postgres e le letture one-shot via socket restituiscono la riga REST
Sezione intitolata “136. Il driver Postgres e le letture one-shot via socket restituiscono la riga REST”A chi si applica: a funzioni o plugin che leggono dati tramite requireDriver(c) / getDriver(c), al codice che invia frame socket FETCH_COLLECTION / FETCH_ONE, e al codice che elaborava oggetti { __type } nelle risposte.
Cosa è cambiato: il formato di lettura è unificato. I metodi fetchCollection e fetchOne del driver Postgres — utilizzati da requireDriver(c), dai plugin, dai frame one-shot del socket, da MCP e dal simulatore RLS — restituiscono il medesimo output di GET /api/data/<table>:
| Valore | Lettura da driver in 0.30 | 0.31 |
|---|---|---|
| timestamp | { "__type": "date", "value": … } |
stringa RFC 3339 |
relazione belongsTo |
{ "__type": "relation", "id", "path" } identificata dal nome della relazione |
la foreign key identificata dal proprio campo (authorId) |
| riga correlata | ogni relazione popolata automaticamente da fetchOne |
unicamente le relazioni specificate in include, strutturate come entità di destinazione |
vector, bytea |
{ "__type": "Vector" }, data URL |
come serializzati da REST |
FetchOneProps accetta il parametro include (ListenOneTarget è rimosso: impiegare FetchOneProps). Le proprietà rebase.data, context.data e l’SDK gestivano già questa struttura e non hanno subito variazioni.
Il pacchetto @rebasepro/client analizza i payload REST e i frame socket considerandoli JSON puro: le strutture contenenti una proprietà __type non vengono più convertite automaticamente in istanze di Date, EntityReference, EntityRelation, GeoPoint o Vector, e gli oggetti JSON che archiviano una chiave __type vengono restituiti esattamente come memorizzati.
Cosa fare: consuma la riga nel suo formato piatto: esegui il parsing delle date partendo dalle stringhe, leggi le foreign key dal loro campo diretto, e indica esplicitamente include per ogni relazione richiesta:
const article = await requireDriver(c).fetchOne({ path: "articles", id });const authorId = article?.author.id; // riferimento { __type: "relation" }const article = await requireDriver(c).fetchOne({ path: "articles", id, include: ["author"] });const authorId = article?.authorId;137. Le interfacce del driver e del backend operano su tabelle, non su collection
Sezione intitolata “137. Le interfacce del driver e del backend operano su tabelle, non su collection”A chi si applica: a sviluppatori di DataDriver personalizzati, adapter per database, o backend realizzati componendo le classi interne di @rebasepro/server.
Cosa è cambiato:
| Prima | Ora |
|---|---|
la prop collection passata ai metodi di DataDriver (fetch, save, delete, count, search, listen) |
rimossa: il driver risolve la tabella elaborata in base a path |
checkUniqueField(path, name, value, id, collection) |
checkUniqueField(path, name, value, id?) |
scanStoredRows({ path, collection, pageSize }) |
scanStoredRows({ path, pageSize }) |
DataDriver.initTextSearch |
rimosso |
DatabaseAdapterInitConfig.collections, .collectionRegistry |
rimossi: l’adapter riceve CompiledTable[] |
BackendServices.collections() |
services.tables() |
serializeCollections, deserializeCollections, isSerializedCollectionRef, SerializedCollectionRef |
rimossi: i descrittori sono esposti tramite GET /api/schema/tables |
AuthAdapter.prepareUserCreation(values, collectionAuth, options?), describeUserCreationContract(collectionAuth) |
prepareUserCreation(values, options?), describeUserCreationContract() |
initializeDriver con ritorno { driver, collectionRegistry, … }; BackendInstance.collectionRegistry |
{ driver, tableRegistry, … }; BackendInstance.tableRegistry |
PolicyEvalContext.entity (di tipo Entity) |
PolicyEvalContext.row (i valori effettivi del record) |
wrapAsSdkData(…) |
buildSdkData(driver); per sorgenti dati multiple: buildRoutedSdkData |
FindResponse in @rebasepro/client |
FindResult |
ListenCollectionRequest, ListenEntityRequest in @rebasepro/server |
ListenCollectionProps, ListenOneProps |
Cosa fare: elimina i parametri deprecati e indirizza le tabelle specificando path. Il codemod evidenzia le occorrenze di implements DataDriver come interventi manuali da verificare. Consulta Integrare il driver Postgres.
138. Il backend accetta esclusivamente i valori documentati nell’API REST
Sezione intitolata “138. Il backend accetta esclusivamente i valori documentati nell’API REST”A chi si applica: ai client che inviano relazioni a uno (to-one) tramite oggetti complessi o vector come { value }, al codice che applica filtri relazionali passando oggetti, a chi importa le classi dei tipi di valore dell’admin, e alle applicazioni offline con mutazioni accodate dalla versione 0.30.
Cosa è cambiato: il formato accettato in scrittura coincide rigorosamente con la struttura restituita in lettura — garantendo una convenzione uniforme per REST, socket, MCP e SDK in-process:
| Valore | Accettato | Rifiutato a partire da ora |
|---|---|---|
relazione to-one (belongsTo, hasOne, una clausola via to-one) |
la chiave del record correlato, oppure null ("" viene valutato come null), valorizzata sotto il nome della relazione o della foreign key |
oggetti come { "id": 5 }: genera l’errore 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.” |
relazione to-many (hasMany, manyToMany, una clausola via to-many scrivibile) |
una lista di chiavi, o di oggetti { id, _pivot? } |
— (altre proprietà presenti nell’oggetto vengono scartate come in precedenza) |
| vector | un array di numeri | istanze di Vector, o { "value": [...] }: errore 400, “‘embedding’ expects a vector as a list of numbers” |
| date, time | testo in formato ISO (o oggetti Date in-process) |
— |
| geopoint | { latitude, longitude } |
— |
bytea |
URL data:application/octet-stream;base64, (Buffer / Uint8Array in-process) |
— |
| filtro su una relazione | il valore della chiave | gli oggetti non vengono estratti: il confronto viene eseguito letteralmente contro l’oggetto fornito |
La versione 0.30 consentiva la scrittura di relazioni to-one passando un oggetto da cui estraeva implicitamente la proprietà id; tale meccanismo non era documentato e rifletteva la struttura interna del view model del pannello di amministrazione. Attualmente, il pannello provvede a convertire il proprio view model nei corrispondenti tipi di rete nel browser prima di ciascuna scrittura o applicazione di filtri.
Le classi di rappresentazione dei valori dell’admin sono state trasferite assieme al resto del view model: EntityReference, EntityRelation, GeoPoint, Vector ed EntityReferenceProps vanno importati da @rebasepro/cms-types (non risiedono più in @rebasepro/types), così come normalizeToEntityRelation (rimosso da @rebasepro/common); withRelationReferencesOnly è rimosso. Il log storico memorizza i record come prodotti in lettura; gli elementi inseriti precedentemente vengono restituiti e ripristinati come valori standard (sezione 132).
La coda offline gestita da @rebasepro/client memorizza direttamente i formati wire. Le scritture salvate in modalità offline tramite l’SDK 0.30 vengono convertite automaticamente al momento del ripristino e della sincronizzazione: nessuna operazione accodata prima della migrazione andrà perduta.
Cosa fare: trasmetti direttamente la chiave: { "author": 5 }, non { "author": { "id": 5 } }; passa i vector come array di numeri e imposta i filtri di relazione indicando la chiave associata. Il comando rebase migrate sdk-calls adatta le importazioni delle classi di valore (l’elenco). Consulta Scritture.
139. /api/docs viene servito al medesimo target dell’endpoint di schema
Sezione intitolata “139. /api/docs viene servito al medesimo target dell’endpoint di schema”A chi si applica: a utenti o processi che consumano /api/docs o visualizzano /api/swagger — come Swagger UI, generatori automatici di client API o pipeline di CI.
Cosa è cambiato: se enableSwagger non è definita (REBASE_ENABLE_SWAGGER non valorizzata), in qualunque ambiente di esecuzione il documento OpenAPI viene esposto unicamente ai client autorizzati a interrogare GET /api/schema/tables, applicando gli stessi criteri di rifiuto — 401 in caso di chiamate anonime a meno che non sia impostato schemaTables.public, 403 per credenziali sprovviste degli ambiti di schema o data — e ogni client ottiene esclusivamente la specifica relativa a tabelle, colonne e relazioni a cui ha facoltà di accedere (gli amministratori ricevono la specifica completa). L’interfaccia Swagger UI non viene esposta. Qualora il server sia privo di autenticazione configurata, la risposta restituita è 404 DOCS_UNAVAILABLE. Al contrario, la 0.30 distribuiva pubblicamente l’intera documentazione di tutte le tabelle e delle colonne non private ai client anonimi in fase di sviluppo, restringendola agli amministratori in produzione.
enableSwagger / REBASE_ENABLE_SWAGGER |
/api/docs |
/api/swagger |
|---|---|---|
| non impostata (default) | limitato ai soli chiamanti autorizzati dall’endpoint di schema: include unicamente le loro tabelle | non esposto |
true |
l’intera specifica, pubblicamente accessibile a chiunque | esposto al di fuori dell’ambiente di produzione |
false |
l’intera specifica, accessibile solo previa autenticazione admin | non esposto |
Cosa fare: invia le richieste verso /api/docs allegando credenziali autenticate. Per ripristinare la pubblicazione globale della documentazione come avveniva in precedenza in sviluppo, imposta REBASE_ENABLE_SWAGGER=true (oppure enableSwagger: true). Vedi Endpoint.
140. La colonna pivot di una many-to-many non può dichiarare .transform()
Sezione intitolata “140. La colonna pivot di una many-to-many non può dichiarare .transform()”A chi si applica: alle definizioni rel.manyToMany(…, { pivot: { … } }) la cui colonna di pivot applica un .transform().
Cosa è cambiato: il compilatore intercetta e rifiuta la configurazione (segnalando “the pivot column “x” declares .transform() …“). Le trasformazioni definite sulle colonne di pivot non venivano eseguite in alcun contesto, con la conseguenza che eventuali valori che si intendeva mascherare venivano esposti in chiaro.
Cosa fare: rimuovi la clausola .transform() e gestisci l’eventuale mascheramento del campo _pivot tramite l’hook hooks.afterRead della tabella target. Consulta Relazioni.
141. Un link eredita esattamente i privilegi di lettura e scrittura della propria colonna chiave
Sezione intitolata “141. Un link eredita esattamente i privilegi di lettura e scrittura della propria colonna chiave”A chi si applica: ai client che valorizzano un belongsTo tramite il nome della relazione, a chi interroga o filtra relazioni la cui colonna chiave è soggetta a restrizioni, o a chi basa il funzionamento su strictWrites: false.
Cosa è cambiato: qualunque vincolo applicato a una colonna chiave si riflette identicamente su tutte le nomenclature impiegate per leggerla o scriverla.
- La valorizzazione di un collegamento tramite il nome della relazione (
{ "reviewer": 7 }) sottostà interamente ai vincoli previsti per la colonna chiave di destinazione —.readOnly(),.private(),access.write, timestamp generati alla creazione, colonna di tenancy e immutabilità della chiave — su REST, operazioni bulk,_batch, socket ed MCP. L’invio contestuale di entrambi i riferimenti ({ "reviewer": 7, "reviewerId": 8 }) con valori divergenti scatena l’errore 400VALIDATION_INVALID_VALUE. Il riassegnamento di un record a un tenant alternativo sfruttando il relativo link solleva 400TENANT_IMMUTABLE(invece di restituire 500). - Una relazione risulta visibile in lettura unicamente qualora il chiamante disponga dei diritti di lettura su tutte le colonne coinvolte nella join, lungo l’intera catena di tabelle attraversate: la chiave del
belongsTo, la foreign key della tabella target per unhasMany/hasOne, e ciascuna delle colonne usate nei passaggi di unvia. Se un controllo fallisce, la relazione viene rimossa daincludee_count, mentre tentativi di filtraggio, ordinamento o navigazione su di essa restituisconoFIELD_NOT_READABLE(o relazione inesistente qualora la colonna sia.private()). Una scrittura su unviato-one che implichi la replica di una colonna non consultabile dal client viene bloccata con l’erroreFIELD_NOT_READABLE. Tali vincoli per i casi inversi e i percorsiviaerano presenti anche nella serie 0.30.x. - Un link la cui colonna chiave non è accessibile in lettura al client viene rimosso da
include, e ogni filtro, ordinamento, indicazione nei campifieldso navigazione relazionale che lo coinvolga risponde conFIELD_NOT_READABLE; un link associato a una chiave configurata come.private()viene trattato come relazione sconosciuta. Dato cheGET /api/schema/tables, OpenAPI e il tool MCPdescribe_tabledocumentano congiuntamente un link e la relativa chiave, anche la presenza della colonna chiave viene occultata qualora il link sia inaccessibile. - L’opzione
strictWrites: falsecontrolla esclusivamente un comportamento: l’inoltro di campi non dichiarati al driver (con persistenza se la colonna esiste nel database, o errore 400VALIDATION_UNKNOWN_FIELDSin caso contrario). Essa non autorizza in nessun caso l’accesso a colonne dichiarate protette, timestamp gestiti, identificativi tenant, vincoli di chiave, destinazioni di relazione o vincoli su_pivot.
Cosa fare: specifica i collegamenti utilizzando una sola chiave, o valorizzandole entrambe con identico dato; interroga le relazioni soggette a restrizioni utilizzando un ruolo abilitato alla lettura della rispettiva chiave. Consulta Accesso ai campi.