Hoppa till innehåll

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

  1. Du skapar db.php i blockkatalogen
  2. Den returnerar ett schema: fält, typer, valideringsregler och åtkomstkontroll
  3. Blockstudio skapar lagringen (tabell, fil eller inläggsmetadata)
  4. Fem REST-slutpunkter genereras automatiskt (lista, hämta, skapa, uppdatera, ta bort)
  5. bs.db() och Db::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.

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

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'],
        ],
    ],
];

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.

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

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

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

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

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

För block med ett schema:

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

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

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

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

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

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

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:

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

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:

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;
  },
});
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.

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

För block med ett schema:

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

PHP
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

PHP
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

  1. Vid sidladdning hämtar klienten en lättviktig hash av de aktuella uppgifterna
  2. Var interval millisekunder hämtar den hashen igen
  3. Om hashen har ändrats hämtar den hela datamängden
  4. De nya uppgifterna skickas till Interactivity-API-lagret via store()
  5. 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:

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

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;
    },
],

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

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."]
    }
  }
}

Varje fält kopplas till en array med felmeddelanden. Flera regler kan fallera för samma fält. 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-slutpunkter

Alla slutpunkter finns under namnrymden blockstudio/v1/db/:

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

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>

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:

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

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']);
        },
    ],
];

Globala hooks

Lyssna på alla scheman var du än befinner dig:

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

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:

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 finns data tillsammans med koden. Kopiera blockmappen till en annan webbplats så följer allt med: UI, logiken, åtkomstkontrollen och själva datan.

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

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