Databas
Databaslagret låter dig definiera en datamodell för ditt block i en db.php
fil. Blockstudio genererar automatiskt REST CRUD-slutpunkter, validerar indata mot
schemat, hanterar lagringen automatiskt och tillhandahåller både en klient för JavaScript
(bs.db()) och en PHP API (klassen Db).
Det här är datagrunden för fullstackblock. Medan RPC hanterar anpassad logik, hanterar databaslagret strukturerade data utan någon standardkod.
Så fungerar det
- Du skapar
db.phpi blockkatalogen - Den returnerar ett schema: fält, typer, valideringsregler och åtkomstkontroll
- Blockstudio skapar lagringen (tabell, fil eller inläggsmetadata)
- Fem REST-slutpunkter genereras automatiskt (lista, hämta, skapa, uppdatera, ta bort)
bs.db()ochDb::get()ger åtkomst från klienten och servern
Inga migreringar, inga styrenheter, ingen ruttregistrering.
Skicka bokstavliga värden till API:erna REST och PHP. Backends meta och post_type hanterar avescaping av WordPress-metadata internt och bevarar omvända snedstreck och citerade strängar i både skalärvärden och nästlade objekt eller arrayer. Escapa inte databaspostvärden i förväg.
Definiera scheman
Enskilt schema
Den enklaste formen: en datamodell per block.
return [
'storage' => 'table',
'capability' => [
'create' => true,
'read' => true,
'update' => 'edit_posts',
'delete' => 'manage_options',
],
'fields' => [
'email' => ['type' => 'string', 'format' => 'email', 'required' => true],
'name' => ['type' => 'string', 'maxLength' => 100],
'plan' => ['type' => 'string', 'enum' => ['free', 'pro'], 'default' => 'free'],
],
];
PHP-inbyggd byggarsyntax
db.php kan också använda en liten byggar-API som bygger på namngivna argument och readonly-definitionsobjekt. Arrayer är fortfarande standardformatet, men det här ger dig ett mer lättupptäckt PHP-inbyggt alternativ när schemat börjar bli större.
<?php
use Blockstudio\Db\Field;
use Blockstudio\Db\Schema;
use Blockstudio\Db\Storage;
return Schema::make(
storage: Storage::Table,
capability: [
'create' => true,
'read' => true,
'update' => 'edit_posts',
'delete' => 'manage_options',
],
fields: [
'email' => Field::string(required: true, format: 'email'),
'name' => Field::string(maxLength: 100),
'plan' => Field::string(enum: ['free', 'pro'], default: 'free'),
],
);
Använd Schema::make() för ett enskilt schema, eller returnera en namngiven array
med anrop till Schema::make(...) för block med flera scheman.
Flera scheman
Ett block kan ha flera datamodeller. Returnera en namngiven array:
return [
'subscribers' => [
'storage' => 'table',
'fields' => [
'email' => ['type' => 'string', 'format' => 'email', 'required' => true],
'plan' => ['type' => 'string', 'enum' => ['free', 'pro']],
],
],
'activity_log' => [
'storage' => 'jsonc',
'fields' => [
'action' => ['type' => 'string', 'required' => true],
'details' => ['type' => 'string'],
],
],
];
Varje schema får egna slutpunkter, egen lagring och egen åtkomstkontroll.
Lagringslägen
Sex lagringslösningar, var och en lämpad för olika användningsfall.
Anpassad tabell (storage: "table")
Varje post är en rad i en dedikerad MySQL-tabell. Blockstudio skapar och hanterar
tabellen automatiskt med funktionen dbDelta() från WordPress. Nya fält i schemat
lägger till kolumner vid nästa sidladdning. Befintliga kolumner tas aldrig
bort.
Passar bäst för: strukturerade data, frågor och produktionsapplikationer.
SQLite (storage: "sqlite")
Varje schema får en egen SQLite-databasfil i en undermapp db/. Blockstudio
skapar filen och tabellen automatiskt och lägger till saknade kolumner när
schemat ändras (som dbDelta för MySQL). Använder WAL-journalföring för bättre
prestanda vid samtidiga läsningar.
blocks/my-block/
├── db.php
└── db/
└── subscribers.sqlite ← single-file database
Passar bäst för: strukturerade data som behöver riktiga SQL-frågor men ska förbli portabla. Hanterar tusentals poster effektivt utan att läsa in allt i minnet. Kopiera mappen för att flytta data.
JSONC-filer (storage: "jsonc")
Poster lagras som ett JSON-objekt per rad i en .jsonc-fil i en undermapp db/.
Filen skapas automatiskt vid den första skrivningen. Rader som börjar med
// behandlas som kommentarer och bevaras.
blocks/my-block/
├── db.php
└── db/
└── subscribers.jsonc ← one record per line
Passar bäst för: små datamängder, konfigurationsliknande data, startposter och exempel som kan versionshanteras. JSONC är avsiktligt en enda fil i din blockmapp. Använd det när du vill att data ska följa med koden, inte när du förväntar dig många samtidiga skrivningar.
Storh-filer (storage: "storh")
Storh lagrar varje post som en separat fil under uppladdningar i WordPress:
wp-content/uploads/blockstudio/db/
└── my-theme-my-block/
└── subscribers/
├── data/
│ └── 00/
│ ├── 00000000-0000-7000-8000-000000000001.jsonc
│ └── 00000000-0000-7000-8000-000000000002.jsonc
├── .storh/
│ └── indexes/
└── .blockstudio/
└── sequence.json
Offentliga post-ID:n förblir samma heltals-ID:n som används i resten av bs.db().
Blockstudio mappar dessa ID:n till Storhs interna UUIDv7-fil-ID:n och lagrar
heltalet id i postens data, så att anropare från JavaScript, REST och PHP inte
behöver hantera UUID:er.
return [
'storage' => 'storh',
'fields' => [
'title' => ['type' => 'string', 'required' => true],
'status' => ['type' => 'string'],
'count' => ['type' => 'integer'],
],
];
Blockstudio skapar Storh-index från ditt schema. Eftersom varje deklarerat fält
kan användas som listfilter indexeras alla deklarerade fält. Fält av typen heltal, tal
och datum använder intervallindex; fält markerade med 'unique' => true
eller 'index' => 'unique' använder unika index.
Passar bäst för: produktionsdata i filer som behöver säkrare samtidiga skrivningar, schemabaserade index och portabel lagring på uppladdningsnivå utan att aktiva poster sparas i blockets källkodsträd.
Migrera JSONC till Storh
Om du började med en .jsonc-fil och vill ha samma poster i Storh kör du:
wp bs db migrate my-theme/app subscribers --to=storh
För block med ett schema:
wp bs db migrate my-theme/app --to=storh
Migreringen läser den befintliga db/{schema}.jsonc, skriver poster till Storh
och bevarar heltals-ID:n, indexerar om, verifierar mållagringen och lämnar
JSONC-filen orörd. För att återställa ändrar du bara schemats storage tillbaka
till "jsonc".
Inläggsmetadata (storage: "meta")
Poster lagras som en JSON-array i WordPress-inläggsmetadata, kopplade till ett visst
inlägg via postId.
return [
'storage' => 'meta',
'postId' => 42,
'fields' => [ /* ... */ ],
];
Passar bäst för: data som hör till ett visst inlägg eller en viss sida.
Anpassad inläggstyp (storage: "post_type")
Varje post är ett WordPress-inlägg i en automatiskt registrerad anpassad inläggstyp. Varje
fält i schemat blir en separat post_meta-post. Det gör posterna sökbara med
WP_Query, kompatibla med tillägg för REST API och synliga för
verktyg som GraphQL.
Passar bäst för: data som ska integreras direkt med WordPress. Varje fält kan sökas och indexeras separat.
JavaScript-klient
Blockstudio injicerar bs.db() på sidor med databasblock. Den returnerar ett
objekt med fem metoder:
const db = bs.db('my-theme/block', 'subscribers');
// Create a record
const record = await db.create({ email: 'a@b.com', plan: 'pro' });
// List all records (with optional filters)
const all = await db.list();
const pros = await db.list({ plan: 'pro', limit: 10, offset: 0 });
// Get a single record
const one = await db.get(record.id);
// Update specific fields
const updated = await db.update(record.id, { plan: 'enterprise' });
// Delete a record
await db.delete(record.id);
Det första argumentet är blocknamnet (med /), det andra är schemanamnet.
För block med ett schema utelämnar du schemanamnet (standardvärdet är "default").
Cache
bs.cache är en frågecache i minnet som delas mellan alla anrop till bs.query och
bs.mutate. Du kan också använda den direkt:
// Read a cached value
const data = bs.cache.get('my-key');
// Write to the cache
bs.cache.set('my-key', { items: [...] });
// Invalidate a single key
bs.cache.invalidate('my-key');
// Clear all cached entries
bs.cache.clear();
Cacheposter lagras i minnet och rensas vid sidnavigering. De används
främst internt av bs.query och bs.mutate, men direkt åtkomst är
användbar för att förinläsa data eller ogiltigförklara den manuellt efter anpassade åtgärder.
Fråga
bs.query() omsluter valfri asynkron funktion med cachning, deduplicering och
kontroll av inaktualitet. Flera anrop med samma nyckel medan en begäran
pågår returnerar samma löfte (inga dubbla hämtningar).
// Basic cached fetch
const subscribers = await bs.query('subscribers', () =>
bs.db('my-theme/app', 'subscribers').list()
);
// With staleTime: skip the fetch if cached data is younger than 30 seconds
const subscribers = await bs.query('subscribers', () =>
bs.db('my-theme/app', 'subscribers').list(),
{ staleTime: 30000 }
);
Det första argumentet är en cache-nyckel (valfri sträng). Det andra är en funktion som returnerar ett löfte. Det tredje är ett valfritt alternativobjekt:
| Alternativ | Typ | Beskrivning |
|---|---|---|
staleTime |
number |
Millisekunder innan cachade data betraktas som inaktuella. 0 (standardvärde) hämtar alltid data igen. |
Om cachen innehåller data för nyckeln och den är yngre än staleTime returneras
det cachade värdet direkt utan att funktionen anropas.
Ändra
bs.mutate() hanterar skrivåtgärder med optimistiska uppdateringar och automatisk
återställning vid fel. Den har två lägen: automatiskt läge för vanliga CRUD-mönster och
manuellt läge för full kontroll.
Automatiskt läge fungerar med ett reaktivt tillståndsobjekt (som Alpine.js $data). Skicka
state, key, action och vid behov optimistic:
// Optimistic create: item appears instantly, gets real ID on success
await bs.mutate({
state: $data,
key: 'todos',
action: 'create',
optimistic: { text: 'New todo', done: false },
fn: () =>
bs.db('my-theme/app', 'todos').create({ text: 'New todo', done: false }),
});
// Optimistic update: field changes instantly, reverts on failure
await bs.mutate({
state: $data,
key: 'todos',
action: 'update',
id: todoId,
optimistic: { done: true },
fn: () => bs.db('my-theme/app', 'todos').update(todoId, { done: true }),
});
// Delete: item removed from the array immediately
await bs.mutate({
state: $data,
key: 'todos',
action: 'delete',
id: todoId,
fn: () => bs.db('my-theme/app', 'todos').delete(todoId),
});
Vid framgång ersätts de optimistiska data med serversvaret. Vid fel återställs tillståndet till en ögonblicksbild som togs före ändringen. Cache-nyckeln ogiltigförklaras automatiskt efter varje lyckad ändring.
Ett misslyckande innebär att löftet som returneras av fn avvisas. bs.db() och
bs.fn() löser sig med felmeddelandet vid valideringsfel, saknad post
eller nekad behörighetskontroll. Kasta därför ett fel när resultatet innehåller code om
även dessa fall ska återställas:
const ok = (request) =>
request.then((result) => {
if (result?.code) {
throw result;
}
return result;
});
await bs.mutate({
state: $data,
key: 'todos',
action: 'delete',
id: todoId,
fn: () => ok(bs.db('my-theme/app', 'todos').delete(todoId)),
});
Vid skapande tilldelas det optimistiska objektet ett tillfälligt id (som __temp_1).
När servern svarar uppdateras det tillfälliga objektet med de faktiska uppgifterna,
inklusive det id som servern tilldelat.
Manuellt läge ger dig full kontroll med återanropsfunktionerna before, onSuccess och
onError:
await bs.mutate({
fn: () => bs.db('my-theme/app', 'todos').create({ text: 'New' }),
invalidate: 'todos',
before: () => {
// Take a snapshot, return it for use in onError
const snapshot = [...$data.todos];
$data.todos.push({ id: '__temp', text: 'New' });
return snapshot;
},
onSuccess: (result, snapshot) => {
// Replace temp item with server response
},
onError: (error, snapshot) => {
// Restore from snapshot
$data.todos = snapshot;
},
});
| Alternativ | Typ | Läge | Beskrivning |
|---|---|---|---|
fn |
function |
Both | Den asynkrona funktion som utför ändringen. Obligatorisk. |
state |
object |
Auto | Reaktivt tillståndsobjekt (e.g., Alpine $data). |
key |
string |
Auto | Egenskapsnamn för arrayen i tillståndet. Används också som cache-nyckel. |
action |
string |
Auto | Ett av create, update eller delete. |
id |
any |
Auto | Post-ID för åtgärderna update och delete. |
optimistic |
object |
Auto | Data som tillämpas optimistiskt innan servern svarar. |
before |
function |
Manual | Anropas före fn. Returvärdet skickas till onSuccess/onError som snapshot. |
onSuccess |
function |
Manual | Anropas med (result, snapshot) vid framgång. |
onError |
function |
Manual | Anropas med (error, snapshot) vid fel. |
invalidate |
string |
Manual | Cache-nyckel som ska ogiltigförklaras vid framgång. |
PHP API
Klassen Db tillhandahåller samma åtgärder på serversidan. Använd den i rpc.php,
cron.php, mallar eller valfri PHP-kod.
use Blockstudio\Db;
$db = Db::get('my-theme/block', 'subscribers');
// Create
$record = $db->create(['email' => 'a@b.com', 'plan' => 'pro']);
// List with filters
$all = $db->list();
$pros = $db->list(['plan' => 'pro'], limit: 10, offset: 0);
// Count and paginate
$count = $db->count(['plan' => 'pro']);
$page = $db->paginate(['plan' => 'pro'], limit: 10, offset: 20);
// Get by ID
$one = $db->get_record(1);
// Update
$db->update(1, ['plan' => 'enterprise']);
// Delete
$db->delete(1);
För block med ett schema:
$db = Db::get('my-theme/block');
Realtidsavläsning
Lägg till realtime i schemat för att aktivera automatisk avläsning. När data ändras
på servern uppdateras UI automatiskt via Interactivity-API-lagret.
Inga ändringar i JavaScript behövs.
return [
'storage' => 'table',
'realtime' => true,
'fields' => [ /* ... */ ],
];
Med true gör Blockstudio en avläsning var tredje sekund och använder schemanamnet som Interactivity-API-nyckel (default för block med ett schema).
Anpassad konfiguration
return [
'storage' => 'table',
'realtime' => [
'key' => 'todos',
'interval' => 5000,
],
'fields' => [ /* ... */ ],
];
| Alternativ | Typ | Standardvärde | Beskrivning |
|---|---|---|---|
key |
string |
schemanamn | Egenskapsnamn i state som innehåller dataarrayen |
interval |
number |
3000 |
Avläsningsintervall i millisekunder |
Så fungerar det
- Vid sidladdning hämtar klienten en lättviktig hash av de aktuella uppgifterna
- Var
intervalmillisekunder hämtar den hashen igen - Om hashen har ändrats hämtar den hela datamängden
- De nya uppgifterna skickas till Interactivity-API-lagret via
store() - Alla direktiv som är kopplade till den tillståndsegenskapen renderas automatiskt på nytt
Avläsningen körs bara på sidor där ett matchande element data-wp-interactive
finns. Den pausas när webbläsarfliken är dold och återupptas när den blir synlig.
Hash-slutpunkten (?_hash=1) returnerar bara en md5-kontrollsumma och antalet poster,
vilket håller avläsningsbegäranden små.
Användaravgränsade data
Ställ in userScoped: true för att automatiskt avgränsa alla poster till den aktuella användaren.
Blockstudio lägger till en user_id-kolumn, anger den när en post skapas och filtrerar alla
åtgärder så att de bara gäller den aktuella användarens poster:
return [
'storage' => 'sqlite',
'userScoped' => true,
'fields' => [
'text' => ['type' => 'string', 'required' => true],
'done' => ['type' => 'boolean', 'default' => false],
],
];
Inget manuellt user_id-fält, ingen before_create-hook och ingen filtrering i RPC. Användare
kan bara se, redigera och ta bort sina egna poster. Kolumnen user_id hanteras
helt av Blockstudio.
Vid lagring med post_type mappar userScoped till post_author i stället för
till en separat user_id-kolumn.
Åtkomstkontroll
Varje CRUD-åtgärd har en egen behörighetsnivå:
| Värde | Beteende |
|---|---|
true |
Offentlig med CSRF-skydd (utloggade användare tillåts, X-BS-Token krävs) |
'open' |
Helt offentlig, ingen CSRF, ingen autentisering (för webhooks och externa API:er) |
'edit_posts' |
Behörighetskontroll för WordPress |
['cap_a', 'cap_b'] |
Användaren behöver minst en av de angivna behörigheterna |
utelämnat / null |
Kräver autentisering (inloggad användare) |
'capability' => [
'create' => true, // public + CSRF protected
'read' => 'open', // truly open, no protection
'update' => 'edit_posts', // editors and above
'delete' => ['delete_posts', 'manage_options'], // either capability works
],
CSRF-skydd
Offentliga slutpunkter (true) skyddas med en X-BS-Token-header. bs.db() och bs.fn() hämtar nya inloggningsuppgifter från en cachadfri slutpunkt med samma ursprung i stället för att bädda in utgående token i sidans HTML. Sidor som levereras från externa cachelagringar med lång livslängd fortsätter att fungera. Anonyma anrop utan en giltig token får ett 403-svar.
Inloggningsuppgifter begärs vid det första anropet till API, inte vid varje sidvisning. Båda klienterna, inklusive databasens realtidsavläsning, delar på en pågående uppdatering av inloggningsuppgifter. Uppgifterna uppdateras efter fem minuters användning. En avvisad WordPress-nonce eller Blockstudio CSRF-token utlöser en uppdatering och ett nytt försök. Vanliga behörighetsfel leder inte till nya försök. Inloggade förfrågningar använder fortfarande den besökande användarens session samt schemats kontroller av behörigheter och postägarskap.
Placera POST /wp-json/blockstudio/v1/client/credentials utanför alla proxy- eller CDN-cachelagringar. Den skickar Cache-Control: private, no-store och kräver en förfrågan med samma ursprung och en icke-enkel header. De inbyggda klienterna hanterar detta automatiskt.
Använd 'open' när du behöver åtkomst som verkligen inte kräver autentisering eller CSRF, till
exempel för inkommande webhooks från externa tjänster.
Fälttyper
| Typ | MySQL-kolumn | Typ i PHP | Beskrivning |
|---|---|---|---|
string |
varchar(maxLength) |
string |
Text, standardvärde för maxLength 255 |
integer |
bigint(20) |
int |
Heltal |
number |
decimal(20,6) |
float |
Decimaltal |
boolean |
tinyint(1) |
bool |
Sant/falskt |
text |
longtext |
string |
Långt textinnehåll |
Validering
Alla skrivningar (skapande och uppdatering) valideras mot schemat innan lagringen
påverkas. Valideringen sker på servern oavsett om begäran kommer från bs.db(), klienten för REST API eller från Db::get().
Inbyggda regler
| Regel | Exempel | Beskrivning |
|---|---|---|
required |
'required' => true |
Fältet måste finnas vid skapande |
type |
'type' => 'integer' |
Värdet måste stämma med den deklarerade typen |
enum |
'enum' => ['a', 'b'] |
Värdet måste vara ett av de angivna alternativen |
maxLength |
'maxLength' => 100 |
Strängen får inte vara längre än så här |
minLength |
'minLength' => 3 |
Strängen måste vara minst så här lång |
format: "email" |
'format' => 'email' |
Måste vara en giltig e-postadress |
format: "url" |
'format' => 'url' |
Måste vara en giltig URL |
Anpassad validering
Lägg till en återanropsfunktion validate i valfritt fält för kontroller på serversidan utöver
de inbyggda reglerna. Returnera true om värdet godkänns, eller en sträng med felmeddelandet:
'email' => [
'type' => 'string',
'format' => 'email',
'required' => true,
'validate' => function ($value, $data) {
if (str_ends_with($value, '@disposable.com')) {
return 'Disposable email addresses are not allowed.';
}
return true;
},
],
Återanropsfunktionen tar emot fältvärdet och hela dataarrayen, så att du kan utföra validering mellan fält.
Format för felsvar
Valideringsfel returnerar statusen 400 med felarrayer för varje fält. Formatet
är inspirerat av Zods fieldErrors och gör
det enkelt att koppla fel till formulärfält:
{
"code": "blockstudio_db_validation",
"message": "Validation failed.",
"data": {
"status": 400,
"errors": {
"email": [
"Must be a valid email address.",
"Disposable email addresses are not allowed."
],
"plan": ["Must be one of: free, pro."]
}
}
}
Varje fält kopplas till en array med felmeddelanden. Flera regler kan fallera för samma fält. På frontend:
const result = await db.create({ email: 'bad', plan: 'invalid' });
if (result.data?.errors) {
// { email: ["Must be a valid email address."], plan: ["Must be one of: free, pro."] }
Object.entries(result.data.errors).forEach(([field, messages]) => {
showFieldError(field, messages[0]);
});
}
REST-slutpunkter
Alla slutpunkter finns under namnrymden blockstudio/v1/db/:
/db/{block-name}/{schema-name}
Blocknamnet har / ersatt med -. För block med ett schema är schemanamnet
default.
| Metod | Slutpunkt | Beskrivning |
|---|---|---|
GET |
/db/{block}/{schema} |
Lista poster |
POST |
/db/{block}/{schema} |
Skapa en post |
GET |
/db/{block}/{schema}/{id} |
Hämta en enskild post |
PUT |
/db/{block}/{schema}/{id} |
Uppdatera en post |
DELETE |
/db/{block}/{schema}/{id} |
Ta bort en post |
Frågeparametrar (lista)
| Parameter | Beskrivning |
|---|---|
limit |
Högsta antal poster att returnera (standardvärde 50, max 100) |
offset |
Antal poster att hoppa över |
| Valfritt fältnamn | Filtrera efter exakt värdematchning |
Exempel: GET /db/my-theme-app/subscribers?plan=pro&limit=10
Formulärrendering
Fält kan definiera en component-nyckel som hänvisar till ett Blockstudio-block. Anropa
bs_db_form() i mallen för att rendera alla fält som ett formulär med deras
komponentblock.
'fields' => [
'email' => [
'type' => 'string',
'format' => 'email',
'required' => true,
'component' => [
'name' => 'my-theme/field',
'attributes' => ['label' => 'Email', 'type' => 'email'],
'innerBlocks' => [
[
'name' => 'my-theme/input',
'attributes' => ['placeholder' => 'Enter your email'],
],
],
],
],
'plan' => [
'type' => 'string',
'enum' => ['free', 'pro'],
'component' => [
'name' => 'my-theme/field',
'attributes' => ['label' => 'Plan'],
'innerBlocks' => [
[
'name' => 'my-theme/select',
'attributes' => ['options' => ['free', 'pro']],
],
],
],
],
],
<form>
<?php bs_db_form('my-theme/app', 'subscribers'); ?>
<button type="submit">Subscribe</button>
</form>
Varje komponent får hela fältdefinitionen som field i sina attribut,
så komponenter kan anpassa sin rendering utifrån schemat. Till exempel
anger $a['field']['name'] fältnamnet, $a['field']['type'] typen,
$a['field']['required'] om det är obligatoriskt osv.
Komponentstrukturen följer samma format med name, attributes, innerBlocks
som WordPress-block. Inre block renderas först och skickas som
$content till det överordnade blocket.
För användning av PHP utan att skriva ut innehållet:
use Blockstudio\Db;
$db = Db::get('my-theme/app', 'subscribers');
$html = $db->form();
Hooks
Åtgärder körs före och efter varje skrivoperation. Alla hooks får en enda
$params-array. Se referensen för Hooks
PHP för hela listan.
Inline-hooks
Definiera hooks direkt i db.php. De begränsas automatiskt till det schemat,
så du behöver inte kontrollera blockets eller schemats namn:
return [
'storage' => 'table',
'fields' => [ /* ... */ ],
'hooks' => [
'after_create' => function ($params) {
// $params['record'] is the created record
wp_mail($params['record']['email'], 'Welcome!', 'Thanks for subscribing.');
},
'before_delete' => function ($params) {
// $params['id'] is the record being deleted
error_log('Deleting subscriber ' . $params['id']);
},
],
];
Globala hooks
Lyssna på alla scheman var du än befinner dig:
add_action('blockstudio/db/after_create', function ($params) {
// $params['block'] and $params['schema'] identify the source
if ('my-theme/app' === $params['block'] && 'subscribers' === $params['schema']) {
// sync to external CRM
}
});
Kombinera med RPC
db.php och rpc.php är oberoende system. db.php genererar CRUD-
slutpunkter från en schemadefinition. rpc.php definierar anpassade serverfunktioner.
Båda fungerar på egen hand.
Använd dem tillsammans när du behöver standardiserade dataoperationer och anpassad affärslogik:
use Blockstudio\Db;
return [
'export' => [
'callback' => function (array $params): array {
$db = Db::get('my-theme/app', 'subscribers');
$rows = $db->list(['plan' => 'pro']);
// custom CSV generation, email sending, etc.
return ['exported' => count($rows)];
},
'capability' => 'manage_options',
],
];
Portabilitet
Med JSONC-lagring finns data tillsammans med koden. Kopiera blockmappen till en annan webbplats så följer allt med: UI, logiken, åtkomstkontrollen och själva datan.
my-app/
├── block.json
├── index.twig
├── style.css
├── rpc.php ← custom endpoints
├── db.php ← data schema
├── cron.php ← scheduled tasks
└── db/
└── entries.jsonc ← the actual data
Inga databasmigreringar, inga export-/importsteg. Kopiera bara mappen.
Även Storh-lagring är portabel, men den finns under uploads/blockstudio/db/
i stället för i blockmappen. Då hålls aktiv, skrivbar data utanför källkodsträdet,
samtidigt som varje schema får en vanlig filbaserad lagring som kan säkerhetskopieras,
kopieras eller migreras separat.
Filter
Ändra scheman programmatiskt utifrån blocket:
add_filter('blockstudio/database', function (array $schemas): array {
// Add a field to an existing schema
$schemas['my-theme/app:subscribers']['fields']['source'] = [
'type' => 'string',
'default' => 'website',
];
return $schemas;
});