Database
Databaselaget lader dig definere en datamodel til din blok i en db.php
fil. Blockstudio genererer REST CRUD-endpoints, validerer input mod skemaet,
håndterer automatisk lagring og stiller både en klient til JavaScript
(bs.db()) og en PHP API (klassen Db) til rådighed.
Dette er datagrundlaget for full-stack-blokke. Hvor RPC håndterer brugerdefineret logik, håndterer databaselaget strukturerede data uden standardkode.
Sådan fungerer det
- Du opretter
db.phpi din blokmappe - Den returnerer et skema: felter, typer, valideringsregler, adgangskontrol
- Blockstudio opretter lageret (tabel, fil eller post-meta)
- Fem REST-endpoints genereres automatisk (list, get, create, update, delete)
bs.db()ogDb::get()giver adgang fra klient og server
Ingen migreringer, controllere eller ruteregistrering.
Send bogstavelige værdier til API’erne REST og PHP. Backends meta og post_type håndterer WordPress-meta-escaping internt og bevarer backslashes og citerede strenge i både skalærværdier og indlejrede objekter eller arrays. Tilføj ikke escaping til databaseposters værdier på forhånd.
Definition af skemaer
Enkelt skema
Den enkleste form: én datamodel pr. blok.
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-native buildersyntaks
db.php kan også bruge en lille builder-API, der bygger på navngivne argumenter og readonly-definitionsobjekter. Arrays er stadig standardformatet, men dette giver dig en mere overskuelig PHP-native mulighed, når skemaet bliver 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'),
],
);
Brug Schema::make() til et enkelt skema, eller returner et navngivet array af
Schema::make(...)-kald for blokke med flere skemaer.
Flere skemaer
En enkelt blok kan have flere datamodeller. Returner et navngivet 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'],
],
],
];
Hvert skema får sine egne endpoints, sit eget lager og sin egen adgangskontrol.
Lagerformer
Seks lagringsbackends, der hver passer til forskellige formål.
Brugerdefineret tabel (storage: "table")
Hver post er en række i en dedikeret MySQL-tabel. Blockstudio opretter og administrerer tabellen automatisk ved hjælp af funktionen dbDelta() fra WordPress. Når der føjes nye felter til skemaet, tilføjes kolonner ved næste sideindlæsning. Eksisterende kolonner fjernes aldrig.
Bedst til: strukturerede data, forespørgsler og produktionsapplikationer.
SQLite (storage: "sqlite")
Hvert skema får sin egen SQLite-databasefil i en undermappe i db/. Blockstudio opretter automatisk filen og tabellen og tilføjer manglende kolonner, når skemaet ændres (som dbDelta for MySQL). Bruger WAL-journaltilstand for at sikre samtidige læsninger.
blocks/my-block/
├── db.php
└── db/
└── subscribers.sqlite ← single-file database
Bedst til: strukturerede data, der kræver rigtige SQL-forespørgsler, men skal forblive flytbare. Håndterer tusindvis af poster effektivt uden at indlæse alt i hukommelsen. Kopiér mappen for at flytte dataene.
JSONC-filer (storage: "jsonc")
Poster gemmes som ét JSON-objekt pr. linje i en .jsonc-fil i en db/-undermappe. Filen oprettes automatisk ved første skrivning. Linjer, der begynder med //, behandles som kommentarer og bevares.
blocks/my-block/
├── db.php
└── db/
└── subscribers.jsonc ← one record per line
Bedst til: små datasæt, konfigurationslignende data, seed-poster og eksempler, der kan versionsstyres. JSONC er bevidst en enkelt fil i din blokmappe. Brug den, når dataene skal følge med koden, ikke når du forventer mange samtidige skrivninger.
Storh-filer (storage: "storh")
Storh gemmer hver post som en separat fil under WordPress-uploads:
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
Offentlige post-id’er forbliver de samme heltals-id’er, som resten af bs.db() bruger.
Blockstudio knytter disse id’er til Storhs interne UUIDv7-fil-id’er og gemmer heltallet id i postdataene, så kald fra JavaScript, REST og PHP ikke behøver at håndtere UUID’er.
return [
'storage' => 'storh',
'fields' => [
'title' => ['type' => 'string', 'required' => true],
'status' => ['type' => 'string'],
'count' => ['type' => 'integer'],
],
];
Blockstudio opbygger Storh-indekser ud fra dit skema. Da alle erklærede felter kan bruges som listefiltre, indekseres hvert erklæret felt. Heltals-, tal- og datolignende felter bruger intervalindekser; felter markeret med 'unique' => true eller 'index' => 'unique' bruger unikke indekser.
Bedst til: filbaserede produktionsdata, der kræver mere sikre samtidige skrivninger, skemaafledte indekser og flytbart lager på uploads-niveau uden at indføre liveposter i blokkens kildetræ.
Migrering af JSONC til Storh
Hvis du begyndte med en .jsonc-fil og vil have de samme poster i Storh, skal du køre:
wp bs db migrate my-theme/app subscribers --to=storh
For blokke med ét skema:
wp bs db migrate my-theme/app --to=storh
Migreringen læser den eksisterende db/{schema}.jsonc, skriver poster til Storh, bevarer heltals-id’er, genindekserer, verificerer mållageret og lader JSONC-filen være urørt. Tilbagerulning klares ved blot at ændre skemaets storage tilbage til "jsonc".
Post-meta (storage: "meta")
Poster gemmes som et JSON-array i WordPress-post-meta, knyttet til et bestemt indlæg via postId.
return [
'storage' => 'meta',
'postId' => 42,
'fields' => [ /* ... */ ],
];
Bedst til: data, der hører til et bestemt indlæg eller en bestemt side.
Brugerdefineret indholdstype (storage: "post_type")
Hver post er et WordPress-indlæg i en automatisk registreret brugerdefineret indholdstype. Hvert felt i skemaet bliver et separat post_meta-felt. Dermed kan der foretages forespørgsler på poster med WP_Query; de er kompatible med plugins til REST API og synlige i værktøjer som GraphQL.
Bedst til: data, der skal integreres direkte med WordPress. Der kan foretages forespørgsler på og indekseres hvert felt uafhængigt.
JavaScript-klient
Blockstudio indsætter bs.db() på sider med databaseblokke. Den returnerer et 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ørste argument er bloknavnet (med /), det andet er skemanavnet.
For blokke med ét skema udelades skemanavnet (standardværdien er "default").
Cache
bs.cache er en forespørgselscache i hukommelsen, der deles på tværs af alle kald til bs.query og bs.mutate. Du kan også bruge den direkte:
// 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 gemmes i hukommelsen og ryddes ved sidenavigation. De bruges primært internt af bs.query og bs.mutate, men direkte adgang er nyttig til at forudfylde data eller manuelt ugyldiggøre cachen efter brugerdefinerede handlinger.
Forespørgsel
bs.query() indpakker en vilkårlig async-funktion med caching, deduplikering og kontrol af forældelse. Flere kald med samme nøgle, mens en forespørgsel er i gang, returnerer det samme promise (ingen dobbelte hentninger).
// 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ørste argument er en cache-nøgle (en vilkårlig streng). Det andet er en funktion, der returnerer et promise. Det tredje er et valgfrit options-objekt:
| Valgmulighed | Type | Beskrivelse |
|---|---|---|
staleTime |
number |
Antal millisekunder, før cachelagrede data betragtes som forældede. 0 (standard) henter altid data igen. |
Hvis cachen indeholder data for nøglen, og de er nyere end staleTime, returneres den cachelagrede værdi straks uden at kalde funktionen.
Ændr
bs.mutate() håndterer skrivehandlinger med optimistiske opdateringer og automatisk tilbagerulning ved fejl. Den har to tilstande: automatisk tilstand til almindelige CRUD-mønstre og manuel tilstand til fuld kontrol.
Automatisk tilstand fungerer med et reaktivt tilstandsobjekt (som Alpine.js $data). Angiv state, key, action og eventuelt 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),
});
Ved succes erstattes de optimistiske data med serverens svar. Ved fejl gendannes tilstanden til et øjebliksbillede fra før ændringen. Cache-nøglen ugyldiggøres automatisk efter hver vellykket ændring.
En fejl betyder, at det promise, som fn returnerer, afvises. bs.db() og bs.fn() opfyldes med fejlindholdet ved valideringsfejl, manglende post eller mislykket tilladelseskontrol. Kast derfor en fejl, når resultatet indeholder en code, hvis disse tilfælde også skal rulles tilbage:
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)),
});
Ved oprettelse tildeles det optimistiske element et midlertidigt id (som __temp_1). Når serveren svarer, opdateres det midlertidige element med de rigtige data, herunder det id, som serveren har tildelt.
Manuel tilstand giver dig fuld kontrol med tilbagekaldsfunktionerne before, onSuccess og 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;
},
});
| Valgmulighed | Type | Tilstand | Beskrivelse |
|---|---|---|---|
fn |
function |
Begge | Async-funktionen, der udfører ændringen. Påkrævet. |
state |
object |
Automatisk | Reaktivt tilstandsobjekt (e.g, Alpine $data). |
key |
string |
Automatisk | Egenskabsnavn på tilstanden, der indeholder arrayet. Bruges også som cache-nøgle. |
action |
string |
Automatisk | En af create, update eller delete. |
id |
any |
Automatisk | Post-id for handlingerne update og delete. |
optimistic |
object |
Automatisk | Data, der anvendes optimistisk, før serveren svarer. |
before |
function |
Manuel | Kaldes før fn. Returværdien sendes til onSuccess/onError som snapshot. |
onSuccess |
function |
Manuel | Kaldes med (result, snapshot) ved succes. |
onError |
function |
Manuel | Kaldes med (error, snapshot) ved fejl. |
invalidate |
string |
Manuel | Cache-nøgle, der skal ugyldiggøres ved succes. |
PHP API
Klassen Db stiller de samme funktioner til rådighed på serversiden. Brug den i rpc.php, cron.php, skabeloner eller vilkårlig PHP-kode.
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);
For blokke med ét skema:
$db = Db::get('my-theme/block');
Polling i realtid
Føj realtime til dit skema for at aktivere automatisk polling. Når data ændres på serveren, opdateres UI automatisk via tilstandslageret i Interactivity API. Ingen ændringer i JavaScript er nødvendige.
return [
'storage' => 'table',
'realtime' => true,
'fields' => [ /* ... */ ],
];
Med true foretager Blockstudio polling hvert 3. sekund og bruger skemanavnet som tilstandsnøgle i Interactivity API (default for blokke med ét skema).
Brugerdefineret konfiguration
return [
'storage' => 'table',
'realtime' => [
'key' => 'todos',
'interval' => 5000,
],
'fields' => [ /* ... */ ],
];
| Valgmulighed | Type | Standard | Beskrivelse |
|---|---|---|---|
key |
string |
skemanavn | Egenskabsnavn på state, der indeholder dataarrayet |
interval |
number |
3000 |
Pollinginterval i millisekunder |
Sådan fungerer det
- Ved sideindlæsning henter klienten en letvægtshash af de aktuelle data
- Hvert
intervalmillisekund henter den hashen igen - Hvis hashen er ændret, henter den hele datasættet
- De nye data sendes til tilstandslageret i Interactivity API via
store() - Direktiver, der er knyttet til denne tilstandsegenskab, gengives automatisk igen
Polling kører kun på sider, hvor der findes et matchende element data-wp-interactive. Den sættes på pause, når browserfanen er skjult, og genoptages, når fanen bliver synlig.
Hash-endpointet (?_hash=1) returnerer kun en md5-kontrolsum og et antal poster, så pollingforespørgslerne forbliver lette.
Brugerspecifikke data
Angiv userScoped: true for automatisk at knytte alle poster til den aktuelle bruger.
Blockstudio tilføjer en user_id-kolonne, angiver den ved oprettelse og filtrerer alle handlinger, så de kun omfatter den aktuelle brugers poster:
return [
'storage' => 'sqlite',
'userScoped' => true,
'fields' => [
'text' => ['type' => 'string', 'required' => true],
'done' => ['type' => 'boolean', 'default' => false],
],
];
Intet manuelt user_id-felt, ingen before_create-hook, ingen filtrering i RPC. Brugere kan kun se, redigere og slette deres egne poster. Kolonnen user_id administreres udelukkende af Blockstudio.
Ved brug af lagringstypen post_type knyttes userScoped til post_author i stedet for en separat user_id-kolonne.
Adgangskontrol
Hver CRUD-handling har sit eget tilladelsesniveau:
| Værdi | Adfærd |
|---|---|
true |
Offentlig med CSRF-beskyttelse (brugere, der er logget ud, tillades; X-BS-Token kræves) |
'open' |
Helt offentlig, uden CSRF eller autentificering (til webhooks og eksterne API’er) |
'edit_posts' |
Kontrol af tilladelsen WordPress |
['cap_a', 'cap_b'] |
Brugeren skal have mindst én af de angivne tilladelser |
udeladt / null |
Kræver autentificering (bruger, der er logget ind) |
'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-beskyttelse
Offentlige endepunkter (true) beskyttes af en X-BS-Token-header. bs.db() og
bs.fn() henter friske legitimationsoplysninger fra et ikke-cachelagret endpoint med samme oprindelse i stedet for at indlejre tokens, der udløber, i sidens HTML. Sider fra eksterne caches med lang levetid fungerer fortsat. Anonyme kald uden et gyldigt token får et 403-svar.
Legitimationsoplysninger hentes ved det første API-kald, ikke ved hver sidevisning. Begge klienter, inklusive databaseafstemning i realtid, deler én igangværende opdatering af legitimationsoplysninger. De opdateres efter fem minutters brug. En afvist WordPress-nonce eller et afvist Blockstudio-CSRF-token udløser én opdatering og et nyt forsøg; almindelige tilladelsesfejl forsøges ikke igen. Anmodninger fra indloggede brugere bruger stadig den besøgende brugers session samt skemaets kontroller af rettigheder og ejerskab af poster.
Hold POST /wp-json/blockstudio/v1/client/credentials uden for enhver proxy- eller CDN-cache.
Den sender Cache-Control: private, no-store og kræver en anmodning med samme oprindelse og en ikke-simpel header. De indbyggede klienter håndterer dette automatisk.
Brug 'open', når du har brug for helt uautentificeret adgang uden CSRF, f.eks. til indgående webhooks fra eksterne tjenester.
Felttyper
| Type | Kolonne MySQL | Type PHP | Beskrivelse |
|---|---|---|---|
string |
varchar(maxLength) |
string |
Tekst, standarden for maxLength er 255 |
integer |
bigint(20) |
int |
Hele tal |
number |
decimal(20,6) |
float |
Decimaltal |
boolean |
tinyint(1) |
bool |
Sandt/falsk |
text |
longtext |
string |
Langt tekstindhold |
Validering
Alle skrivninger (oprettelse og opdatering) valideres mod skemaet, før lageret berøres. Valideringen sker på serversiden, uanset om anmodningen kommer fra bs.db(), klienten REST API eller Db::get().
Indbyggede regler
| Regel | Eksempel | Beskrivelse |
|---|---|---|
required |
'required' => true |
Feltet skal være til stede ved oprettelse |
type |
'type' => 'integer' |
Værdien skal svare til den angivne type |
enum |
'enum' => ['a', 'b'] |
Værdien skal være en af de angivne muligheder |
maxLength |
'maxLength' => 100 |
Strengen må ikke overskride denne længde |
minLength |
'minLength' => 3 |
Strengen skal mindst have denne længde |
format: "email" |
'format' => 'email' |
Skal være en gyldig e-mailadresse |
format: "url" |
'format' => 'url' |
Skal være en gyldig URL |
Brugerdefineret validering
Tilføj en validate-tilbagekaldsfunktion til et vilkårligt felt for kontroller på serversiden, der går ud over de indbyggede regler. Returner true for at godkende, eller en streng med fejlmeddelelsen:
'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;
},
],
Tilbagekaldsfunktionen modtager feltværdien og hele dataarrayet, så du kan udføre validering på tværs af felter.
Fejlsvarformat
Valideringsfejl returnerer status 400 med fejlsarrays for hvert felt. Formatet er inspireret af Zods fieldErrors og gør det nemt at knytte fejl til formularfelter:
{
"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."]
}
}
}
Hvert felt knyttes til et array af fejlstrenge. Flere regler kan fejle for samme felt. 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-endpoints
Alle endpoints ligger under navnerummet blockstudio/v1/db/:
/db/{block-name}/{schema-name}
Bloknavnet får / erstattet med -. For blokke med ét skema er skemanavnet default.
| Metode | Endpoint | Beskrivelse |
|---|---|---|
GET |
/db/{block}/{schema} |
Vis poster |
POST |
/db/{block}/{schema} |
Opret en post |
GET |
/db/{block}/{schema}/{id} |
Hent en enkelt post |
PUT |
/db/{block}/{schema}/{id} |
Opdater en post |
DELETE |
/db/{block}/{schema}/{id} |
Slet en post |
Forespørgselsparametre (liste)
| Parameter | Beskrivelse |
|---|---|
limit |
Højeste antal poster, der returneres (standard 50, maks. 100) |
offset |
Antal poster, der skal springes over |
| Ethvert feltnavn | Filtrer efter præcist værdi-match |
Eksempel: GET /db/my-theme-app/subscribers?plan=pro&limit=10
Gengivelse af formularer
Felter kan angive en component-nøgle, der henviser til en Blockstudio-blok. Kald bs_db_form() i din skabelon for at gengive alle felter som en formular ved hjælp af deres komponentblokke.
'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>
Hver komponent modtager den fulde feltdefinition som field i sine attributter, så komponenter kan tilpasse deres visning efter skemaet. For eksempel angiver $a['field']['name'] feltnavnet, $a['field']['type'] typen, $a['field']['required'] om det er påkrævet osv.
Komponentstrukturen følger samme format med name, attributes, innerBlocks som WordPress-blokke. Indre blokke gengives først og sendes som $content til den overordnede blok.
Til brug af PHP uden ekko:
use Blockstudio\Db;
$db = Db::get('my-theme/app', 'subscribers');
$html = $db->form();
Hooks
Handlinger udløses før og efter hver skriveoperation. Alle hooks modtager ét $params-array. Se referencen til PHP Hooks for den fulde liste.
Inline-hooks
Definér hooks direkte i db.php. De er automatisk afgrænset til det pågældende skema, så du behøver ikke kontrollere blok- eller skemanavnet:
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']);
},
],
];
Globale hooks
Lyt på tværs af alle skemaer, uanset hvorfra:
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
}
});
Kombination med RPC
db.php og rpc.php er uafhængige systemer. db.php genererer CRUD-endpoints ud fra en skemadefinition. rpc.php definerer brugerdefinerede serverfunktioner. Hvert system kan bruges alene.
Brug dem sammen, når du har brug for standarddataoperationer og brugerdefineret forretningslogik:
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 ligger data sammen med koden. Kopiér blokmappen til et andet websted, så følger alt med: UI, logikken, adgangskontrollen og selve dataene.
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
Ingen databasemigreringer og ingen eksport- eller importtrin. Kopiér blot mappen.
Storh-lagring er også portabel, men ligger under uploads/blockstudio/db/ i stedet for i blokmappen. Så holdes aktive, skrivbare data ude af kildetræet, samtidig med at hvert skema har et fillager i almindeligt format, som kan sikkerhedskopieres, kopieres eller migreres uafhængigt.
Filtrering
Redigér skemaer programmatisk uden for blokken:
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;
});