База данни
Слоят за базата данни ви позволява да дефинирате модел на данни за блока си във файл db.php. Blockstudio генерира CRUD крайни точки REST, валидира входните данни спрямо схемата, управлява автоматично хранилището и предоставя както клиентски JavaScript (bs.db()), така и сървърен PHP API (клас Db).
Това е гръбнакът за данни на блоковете с пълен стек. Докато RPC се грижи за персонализираната логика, слоят за базата данни обработва структурираните данни без шаблонен код.
Как работи
- Създавате
db.phpв директорията на блока си - Той връща схема: полета, типове, правила за валидация и контрол на достъпа
- Blockstudio създава хранилището (таблица, файл или метаданни на публикация)
- Автоматично се генерират пет крайни точки REST (списък, получаване, създаване, актуализиране, изтриване)
bs.db()иDb::get()предоставят клиентски и сървърен достъп
Без миграции, контролери или регистриране на маршрути.
Подайте буквални стойности към API-тата REST и PHP. Бекендите meta и post_type обработват вътрешно наклонените черти в метаданните на WordPress, като запазват обратните наклонени черти и низовете в кавички както в скаларните стойности, така и във вложените обекти или масиви. Не добавяйте предварително наклонени черти към стойностите на записите в базата данни.
Дефиниране на схеми
Единична схема
Най-простият вариант: един модел на данни за всеки блок.
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
db.php може да използва и малък конструктор API, базиран на именувани аргументи и неизменяеми обекти за дефиниции. Масивите остават форматът по подразбиране, но това ви дава по-лесна за откриване опция с поддръжка на 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'),
],
);
Използвайте Schema::make() за единична схема или върнете масив от именувани извиквания на Schema::make(...) за блокове с няколко схеми.
Няколко схеми
Един блок може да съдържа няколко модела на данни. Върнете именуван масив:
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'],
],
],
];
Всяка схема получава собствени крайни точки, хранилище и контрол на достъпа.
Режими на съхранение
Шест хранилища, всяко подходящо за различни случаи на употреба.
Персонализирана таблица (storage: "table")
Всеки запис е ред в отделна таблица MySQL. Blockstudio създава и управлява таблицата автоматично чрез функцията dbDelta() на WordPress. Добавянето на нови полета към схемата добавя колони при следващото зареждане на страницата. Съществуващите колони никога не се премахват.
Най-подходящо за: структурирани данни, заявки и приложения в продукционна среда.
SQLite (storage: "sqlite")
Всяка схема получава собствен файл с база данни SQLite в подпапка db/. Blockstudio създава автоматично файла и таблицата и добавя липсващите колони при промяна на схемата (като dbDelta за MySQL). Използва режим за журнал WAL за паралелно четене.
blocks/my-block/
├── db.php
└── db/
└── subscribers.sqlite ← single-file database
Най-подходящо за: структурирани данни, за които са нужни истински заявки SQL, но които трябва да останат преносими. Ефективно обработва хиляди записи, без да зарежда всичко в паметта. Копирайте папката, за да преместите данните.
Файлове JSONC (storage: "jsonc")
Записите се съхраняват като по един обект JSON на ред във файл .jsonc в подпапка db/. Файлът се създава автоматично при първия запис. Редовете, започващи с //, се третират като коментари и се запазват.
blocks/my-block/
├── db.php
└── db/
└── subscribers.jsonc ← one record per line
Най-подходящо за: малки набори от данни, данни като конфигурация, начални записи и примери с контрол на версиите. JSONC умишлено е един файл в папката на блока ви. Използвайте го, когато искате данните да се движат заедно с кода, а не когато очаквате много паралелни записи.
Файлове Storh (storage: "storh")
Storh съхранява всеки запис в отделен файл в 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
Публичните идентификатори на записите остават същите целочислени ID, използвани в останалата част на bs.db(). Blockstudio свързва тези ID с вътрешните файлови ID UUIDv7 на Storh и съхранява целочисления id в данните на записа, така че извикващите от JavaScript, REST и PHP не трябва да обработват UUID.
return [
'storage' => 'storh',
'fields' => [
'title' => ['type' => 'string', 'required' => true],
'status' => ['type' => 'string'],
'count' => ['type' => 'integer'],
],
];
Blockstudio изгражда индекси Storh от схемата ви. Тъй като всяко декларирано поле може да се използва като филтър за списъка, всяко декларирано поле се индексира. Полетата с цели числа, числа и дати използват индекси за диапазон; полетата, маркирани с 'unique' => true или 'index' => 'unique', използват уникални индекси.
Най-подходящо за: продукционни данни, съхранявани във файлове, за които са нужни по-безопасни паралелни записи, индекси, извлечени от схемата, и преносимо хранилище на ниво качвания, без записите в реално време да се включват в дървото с изходния код на блока.
Мигриране от JSONC към Storh
Ако сте започнали с файл .jsonc и искате същите записи в Storh, изпълнете:
wp bs db migrate my-theme/app subscribers --to=storh
За блокове с една схема:
wp bs db migrate my-theme/app --to=storh
Миграцията прочита съществуващия db/{schema}.jsonc, записва данните в Storh, като запазва целочислените ID, изгражда индексите отново, проверява целевото хранилище и оставя файла JSONC непокътнат. За връщане назад просто променете storage на схемата обратно на "jsonc".
Метаданни на публикация (storage: "meta")
Записите се съхраняват като масив JSON в метаданните на публикацията WordPress и са свързани с конкретна публикация чрез postId.
return [
'storage' => 'meta',
'postId' => 42,
'fields' => [ /* ... */ ],
];
Най-подходящо за: данни, свързани с конкретна публикация или страница.
Персонализиран тип публикация (storage: "post_type")
Всеки запис е публикация WordPress в автоматично регистриран персонализиран тип публикация. Всяко поле в схемата се превръща в отделен запис post_meta. Така записите могат да се заявяват с WP_Query, съвместими са с плъгините REST API и са видими за инструменти като GraphQL.
Най-подходящо за: данни, които трябва да се интегрират естествено с WordPress. Всяко поле може да се заявява и индексира самостоятелно.
Клиент JavaScript
Blockstudio добавя bs.db() към страниците с блокове за бази данни. Връща обект с пет метода:
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);
Първият аргумент е името на блока (с /), а вторият е името на схемата. При блокове с една схема пропуснете името на схемата (по подразбиране е "default").
Кеш
bs.cache е кеш на заявките в паметта, споделян от всички извиквания на bs.query и bs.mutate. Можете да го използвате и директно:
// 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();
Записите в кеша се съхраняват в паметта и се изчистват при навигация между страници. Използват се основно вътрешно от bs.query и bs.mutate, но директният достъп е полезен за предварително зареждане на данни или ръчно обезсилване след персонализирани операции.
Заявка
bs.query() обгръща всяка асинхронна функция с кеширане, премахване на дублиранията и контрол на остаряването. Няколко извиквания с един и същ ключ, докато заявката е в ход, връщат едно и също обещание (без дублирани извличания).
// 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 }
);
Първият аргумент е ключ за кеша (произволен низ). Вторият е функция, която връща обещание. Третият е незадължителен обект с опции:
| Опция | Тип | Описание |
|---|---|---|
staleTime |
number |
Милисекунди, преди кешираните данни да се считат за остарели. 0 (по подразбиране) винаги извлича данните отново. |
Ако в кеша има данни за ключа и те са по-нови от staleTime, кешираната стойност се връща веднага, без да се извиква функцията.
Промяна
bs.mutate() обработва операциите за запис с оптимистични актуализации и автоматично връщане назад при неуспех. Има два режима: автоматичен за обичайните CRUD модели и ръчен за пълен контрол.
Автоматичният режим работи с реактивен обект за състояние (например Alpine.js $data). Подайте state, key, action и по избор 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),
});
При успех оптимистичните данни се заменят с отговора от сървъра. При неуспех състоянието се връща към моментна снимка, направена преди промяната. Ключът на кеша автоматично се обезсилва след всяка успешна промяна.
Неуспех означава, че обещанието, върнато от fn, е отхвърлено. bs.db() и bs.fn() разрешават обещанието с тялото на грешката при грешка във валидацията, липсващ запис или неуспешна проверка на разрешенията. Затова хвърлете грешка, когато резултатът съдържа code, ако и тези случаи трябва да задействат връщане назад:
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)),
});
При операции за създаване на оптимистичния елемент се задава временно id (например __temp_1). Когато сървърът отговори, временният елемент се актуализира с реалните данни, включително присвоеното от сървъра id.
Ръчният режим ви дава пълен контрол чрез обратните извиквания before, onSuccess и 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;
},
});
| Опция | Тип | Режим | Описание |
|---|---|---|---|
fn |
function |
И двата | Асинхронната функция, която извършва промяната. Задължителна. |
state |
object |
Автоматичен | Реактивен обект за състояние (e.g., Alpine $data). |
key |
string |
Автоматичен | Име на свойството в състоянието, което съдържа масива. Използва се и като ключ за кеша. |
action |
string |
Автоматичен | Едно от create, update или delete. |
id |
any |
Автоматичен | ID на записа за действията update и delete. |
optimistic |
object |
Автоматичен | Данни, които да се приложат оптимистично преди отговора от сървъра. |
before |
function |
Ръчен | Извиква се преди fn. Върнатата стойност се подава на onSuccess/onError като snapshot. |
onSuccess |
function |
Ръчен | Извиква се с (result, snapshot) при успех. |
onError |
function |
Ръчен | Извиква се с (error, snapshot) при неуспех. |
invalidate |
string |
Ръчен | Ключ на кеша за обезсилване при успех. |
PHP API
Класът Db предоставя същите операции от страна на сървъра. Използвайте го в rpc.php, cron.php, шаблони или произволен код 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);
За блокове с една схема:
$db = Db::get('my-theme/block');
Периодично обновяване в реално време
Добавете realtime към схемата си, за да активирате автоматичното периодично обновяване. Когато данните се променят на сървъра, UI се актуализира автоматично чрез хранилището на Interactivity API. Не са нужни промени в JavaScript.
return [
'storage' => 'table',
'realtime' => true,
'fields' => [ /* ... */ ],
];
С true Blockstudio проверява за промени на всеки 3 секунди, като използва името на схемата като ключ за състоянието на Interactivity API (default за блокове с една схема).
Персонализирана конфигурация
return [
'storage' => 'table',
'realtime' => [
'key' => 'todos',
'interval' => 5000,
],
'fields' => [ /* ... */ ],
];
| Опция | Тип | По подразбиране | Описание |
|---|---|---|---|
key |
string |
име на схемата | Име на свойството в state, което съдържа масива с данни |
interval |
number |
3000 |
Интервалът за периодично обновяване в милисекунди |
Как работи
- При зареждане на страницата клиентът извлича олекотен хеш на текущите данни
- На всеки
intervalмилисекунди извлича хеша отново - Ако хешът се е променил, извлича пълния набор от данни
- Новите данни се изпращат в хранилището за състояние на Interactivity API чрез
store() - Всички директиви, свързани с това свойство на състоянието, се визуализират отново автоматично
Периодичното обновяване се изпълнява само на страници, където има съответстващ елемент data-wp-interactive. То спира, когато разделът на браузъра е скрит, и се възобновява, когато стане видим.
Крайната точка за хеша (?_hash=1) връща само контролна сума md5 и брой записи, за да запази заявките за периодично обновяване леки.
Данни, обхванати до потребителя
Задайте userScoped: true, за да ограничите автоматично всички записи до текущия потребител. Blockstudio добавя колона user_id, задава стойността ѝ при създаване и ограничава всички операции само до записите на текущия потребител:
return [
'storage' => 'sqlite',
'userScoped' => true,
'fields' => [
'text' => ['type' => 'string', 'required' => true],
'done' => ['type' => 'boolean', 'default' => false],
],
];
Без ръчно поле user_id, без хук before_create и без филтриране в RPC. Потребителите могат да виждат, редактират и изтриват само собствените си записи. Колоната user_id се управлява изцяло от Blockstudio.
При използване на хранилище post_type, userScoped се съпоставя с post_author вместо с отделна колона user_id.
Контрол на достъпа
Всяка CRUD операция има собствено ниво на разрешения:
| Стойност | Поведение |
|---|---|
true |
Публичен достъп със защита срещу CSRF (допуска се достъп без вход, изисква се X-BS-Token) |
'open' |
Напълно публичен достъп без CSRF и удостоверяване (за уебкуки и външни API) |
'edit_posts' |
Проверка на възможностите WordPress |
['cap_a', 'cap_b'] |
Потребителят трябва да има поне една от изброените възможности |
пропуснато / null |
Изисква удостоверяване (потребителят трябва да е влязъл) |
'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
Публичните крайни точки (true) са защитени с хедър X-BS-Token. bs.db() и bs.fn() извличат актуални идентификационни данни от кеширана крайна точка със същия произход, вместо да вграждат изтичащи токени в HTML на страницата. Страниците, обслужвани от външни кешове с дълъг срок на съхранение, продължават да работят. Анонимните заявки без валиден токен получават отговор 403.
Идентификационните данни се заявяват при първото извикване на API, а не при всяко преглеждане на страница. Двата клиента, включително периодичните заявки за данни в реално време от базата данни, споделят едно текущо обновяване на идентификационните данни. Те се обновяват след пет минути употреба. Отхвърлен WordPress nonce или CSRF токен Blockstudio задейства едно обновяване и повторен опит; обикновените грешки с разрешения не се повтарят. Влезлите в профила си потребители продължават да използват сесията на посетителя и проверките за права и собственост върху записите, зададени в схемата.
Дръжте POST /wp-json/blockstudio/v1/client/credentials извън кеша на прокси или CDN. То изпраща Cache-Control: private, no-store и изисква заявка със същия произход и нестандартен хедър. Вградените клиенти обработват това автоматично.
Използвайте 'open', когато ви е нужен напълно неавтентикиран достъп без CSRF, например за входящи уебкуки от външни услуги.
Типове полета
| Тип | Колона MySQL | Тип PHP | Описание |
|---|---|---|---|
string |
varchar(maxLength) |
string |
Текст, максималната дължина по подразбиране е 255 |
integer |
bigint(20) |
int |
Цели числа |
number |
decimal(20,6) |
float |
Десетични числа |
boolean |
tinyint(1) |
bool |
Вярно/невярно |
text |
longtext |
string |
Дългоформатно текстово съдържание |
Валидация
Всички записи (създаване и актуализиране) се валидират спрямо схемата, преди данните да бъдат записани в хранилището. Валидацията се извършва от страната на сървъра, независимо дали заявката идва от bs.db(), REST API или Db::get().
Вградени правила
| Правило | Пример | Описание |
|---|---|---|
required |
'required' => true |
Полето трябва да присъства при създаване |
type |
'type' => 'integer' |
Стойността трябва да съответства на декларирания тип |
enum |
'enum' => ['a', 'b'] |
Стойността трябва да е една от изброените опции |
maxLength |
'maxLength' => 100 |
Низът не може да надвишава тази дължина |
minLength |
'minLength' => 3 |
Низът трябва да е поне с тази дължина |
format: "email" |
'format' => 'email' |
Трябва да е валиден имейл адрес |
format: "url" |
'format' => 'url' |
Трябва да е валиден URL |
Персонализирана валидация
Добавете обратно извикване validate към което и да е поле за проверки от страна на сървъра, които надхвърлят вградените правила. Върнете true при успех или низ със съобщението за грешка:
'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;
},
],
Обратното извикване получава стойността на полето и целия масив с данни, което позволява валидация между полета.
Формат на отговора при грешка
Грешките при валидация връщат статус 400 с масиви от грешки за всяко поле. Този формат е вдъхновен от ZodfieldErrors и улеснява свързването на грешките с полетата във формуляра:
{
"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."]
}
}
}
Всяко поле се свързва с масив от низове с грешки. Едно и също поле може да нарушава няколко правила. Във фронтенда:
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
Всички крайни точки са в пространството от имена blockstudio/v1/db/:
/db/{block-name}/{schema-name}
В името на блока / се заменя с -. При блокове с една схема името на схемата е default.
| Метод | Крайна точка | Описание |
|---|---|---|
GET |
/db/{block}/{schema} |
Извеждане на списък със записи |
POST |
/db/{block}/{schema} |
Създаване на запис |
GET |
/db/{block}/{schema}/{id} |
Получаване на единичен запис |
PUT |
/db/{block}/{schema}/{id} |
Актуализиране на запис |
DELETE |
/db/{block}/{schema}/{id} |
Изтриване на запис |
Параметри на заявката (списък)
| Параметър | Описание |
|---|---|
limit |
Максимален брой записи за връщане (по подразбиране 50, максимум 100) |
offset |
Брой записи за пропускане |
| Име на което и да е поле | Филтриране по точно съвпадение на стойността |
Пример: GET /db/my-theme-app/subscribers?plan=pro&limit=10
Визуализиране на формуляри
Полетата могат да зададат ключ component, който препраща към блок Blockstudio. Извикайте bs_db_form() в шаблона си, за да визуализирате всички полета като формуляр чрез техните компонентни блокове.
'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>
Всеки компонент получава пълната дефиниция на полето като field в атрибутите си, така че компонентите могат да адаптират визуализацията си според схемата. Например $a['field']['name'] предоставя името на полето, $a['field']['type'] — типа, $a['field']['required'] — дали е задължително, и т.н.
Структурата на компонента следва същия формат name, attributes, innerBlocks като блоковете WordPress. Вътрешните блокове се визуализират първи и се предават като $content на родителския блок.
За използване на PHP без извеждане:
use Blockstudio\Db;
$db = Db::get('my-theme/app', 'subscribers');
$html = $db->form();
Куки
Действията се изпълняват преди и след всяка операция за запис. Всички hooks получават един масив $params. Вижте справочника за hooks PHP, където е пълният списък.
Hooks за конкретен блок
Дефинирайте hooks директно в db.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']);
},
],
];
Глобални hooks
Следете всички схеми отвсякъде:
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
}
});
Комбиниране с RPC
db.php и rpc.php са независими системи. db.php генерира CRUD крайни точки от дефиниция на схема. rpc.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',
],
];
Преносимост
При съхранение в JSONC данните се намират заедно с кода. Копирайте папката на блока в друг сайт и всичко ще се прехвърли заедно: UI, логиката, контролът на достъпа и самите данни.
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
Без миграции на базата данни и без стъпки за експортиране или импортиране. Просто копирайте папката.
Съхранението в Storh също е преносимо, но се намира в uploads/blockstudio/db/, а не в папката на блока. Така активните данни, които могат да се променят, остават извън дървото на изходния код, а всяка схема разполага с хранилище във файлове, което може да се архивира, копира или мигрира самостоятелно.
Филтриране
Променяйте схемите програмно извън блока:
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;
});