Gå til indhold

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

  1. Du opretter db.php i din blokmappe
  2. Den returnerer et skema: felter, typer, valideringsregler, adgangskontrol
  3. Blockstudio opretter lageret (tabel, fil eller post-meta)
  4. Fem REST-endpoints genereres automatisk (list, get, create, update, delete)
  5. bs.db() og Db::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.

PHP
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
<?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:

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

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

Kode
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:

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

PHP
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:

Shell
wp bs db migrate my-theme/app subscribers --to=storh

For blokke med ét skema:

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

PHP
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:

JavaScript
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:

JavaScript
// 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).

JavaScript
// 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:

JavaScript
// 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:

JavaScript
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:

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

PHP
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:

PHP
$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.

PHP
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

PHP
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

  1. Ved sideindlæsning henter klienten en letvægtshash af de aktuelle data
  2. Hvert interval millisekund henter den hashen igen
  3. Hvis hashen er ændret, henter den hele datasættet
  4. De nye data sendes til tilstandslageret i Interactivity API via store()
  5. 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:

PHP
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)
PHP
'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:

PHP
'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:

JSON
{
  "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:

JavaScript
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/:

Kode
/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.

PHP
'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']],
                ],
            ],
        ],
    ],
],
PHP
<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:

PHP
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:

PHP
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:

PHP
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:

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

Kode
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:

PHP
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;
});