2026-10-16 · 11 min
Schema Markup Menu Restoran: Generate JSON-LD dari Database
Setiap 16 Oktober, dunia memperingati Hari Pangan Sedunia, dan setiap tahun di sekitar tanggal itu saya teringat masalah yang paling sering saya temukan di klien kuliner: schema markup menu restoran yang isinya sudah tidak sama dengan menu aslinya. Harga nasi goreng di website Rp25.000, di JSON-LD masih Rp22.000 dari dua tahun lalu, dan di Google Business Profile ada menu yang sudah tidak dijual sejak Lebaran. Pemilik warung tidak salah. Menu berubah terus, sementara datanya tersebar di tiga tempat yang diperbarui dengan tangan oleh orang yang berbeda.
Di artikel sebelumnya soal JSON-LD LocalBusiness untuk landing page SMB, fokusnya adalah data identitas bisnis yang jarang berubah: nama, alamat, telepon. Kali ini kita masuk ke data yang justru paling sering berubah, yaitu menu dan harga. Pendekatan saya sebagai konsultan local SEO sederhana: menu cukup ditulis di satu tempat, yaitu database. Halaman menu, JSON-LD, dan daftar perubahan untuk Google Business Profile semuanya dihasilkan dari sumber yang sama.
Tutorial ini saya bagi menjadi enam langkah. Semua kode memakai PostgreSQL dan Node.js (versi 20 ke atas) dengan Express dan pg, tetapi polanya bisa dipindahkan ke stack apa pun.
Kenapa Menu Restoran Paling Sering Tidak Sinkron
Dari pengalaman mengaudit website kuliner, pola masalahnya hampir selalu salah satu dari ini:
- JSON-LD ditulis tangan sekali saat website dibuat, lalu tidak pernah disentuh lagi. Harga di halaman sudah diperbarui, harga di markup tidak.
- Menu hanya berupa foto atau PDF. Pengunjung bisa membacanya, tetapi mesin pencari harus menebak isinya, dan tidak ada data terstruktur sama sekali.
- Harga dari aplikasi pesan antar ikut tercampur. Harga di aplikasi ojek online sering berbeda dari harga makan di tempat, sesuai kebijakan masing-masing restoran. Kalau website menampilkan harga dine-in tetapi JSON-LD memakai harga aplikasi, datanya saling bertentangan.
- Google Business Profile diperbarui oleh orang lain. Biasanya pemilik atau kasir, lewat HP, tanpa catatan item apa saja yang berubah.
Pedoman Google untuk structured data jelas: markup harus mewakili konten yang terlihat di halaman. Jadi masalahnya bukan sekadar “kurang rapi”. Markup yang isinya berbeda dari halaman justru bertentangan dengan pedoman itu. Solusi teknisnya adalah membuat ketidaksinkronan menjadi mustahil secara struktur, bukan sekadar mengandalkan disiplin manusia.
Langkah 1: Modelkan Tabel Menu yang Sederhana
Tiga tabel sudah cukup: restaurant, menu_section, dan menu_item. Ada beberapa keputusan desain yang sengaja saya ambil di sini.
CREATE TABLE restaurant (
id serial PRIMARY KEY,
slug text UNIQUE NOT NULL,
name text NOT NULL,
url text NOT NULL,
menu_url text NOT NULL,
telephone text NOT NULL,
street text NOT NULL,
locality text NOT NULL,
region text NOT NULL,
postal_code text,
serves_cuisine text[] NOT NULL DEFAULT '{}',
price_range text,
gbp_synced_at timestamptz
);
CREATE TABLE menu_section (
id serial PRIMARY KEY,
restaurant_id int NOT NULL REFERENCES restaurant(id) ON DELETE CASCADE,
name text NOT NULL,
position int NOT NULL DEFAULT 0
);
CREATE TABLE menu_item (
id serial PRIMARY KEY,
section_id int NOT NULL REFERENCES menu_section(id) ON DELETE CASCADE,
name text NOT NULL,
description text,
price_idr integer NOT NULL CHECK (price_idr >= 0),
is_available boolean NOT NULL DEFAULT true,
diet text[] NOT NULL DEFAULT '{}'
CHECK (diet <@ ARRAY['halal', 'vegetarian', 'vegan', 'gluten_free']),
position int NOT NULL DEFAULT 0,
updated_at timestamptz NOT NULL DEFAULT now()
);
-- updated_at diperbarui otomatis setiap kali item diubah
CREATE OR REPLACE FUNCTION touch_updated_at() RETURNS trigger AS $$
BEGIN
NEW.updated_at := now();
RETURN NEW;
END;
$$ LANGUAGE plpgsql;
CREATE TRIGGER menu_item_touch
BEFORE UPDATE ON menu_item
FOR EACH ROW EXECUTE FUNCTION touch_updated_at();
Alasan di balik desain ini:
price_idrberupainteger. Rupiah praktis tidak memakai pecahan, dan integer menghindari masalah pembulatan sekaligus membuatpgmengembalikannya sebagai angka JavaScript biasa. Kolomnumericakan dikembalikan sebagai string.is_availablealih-alihDELETE. Menu musiman atau menu yang dihapus cukup dinonaktifkan. Dengan begitu perubahannya tetap tercatat lewatupdated_at, dan nanti muncul di daftar perubahan untuk Google Business Profile. Baris yang dihapus tidak meninggalkan jejak.dietdibatasiCHECK. Hanya empat nilai yang boleh masuk, dan masing-masing punya padanan di enumerasiRestrictedDietschema.org. Tidak ada ruang untuk salah ketik seperti “halall”.- Trigger
updated_at. Developer tidak perlu ingat mengisinya di setiap queryUPDATE.
Untuk mencoba, isi dengan data contoh berikut. Semua data ini fiktif, dan ID-nya mengasumsikan database yang masih baru:
INSERT INTO restaurant (slug, name, url, menu_url, telephone, street, locality, region, serves_cuisine, price_range)
VALUES ('warung-contoh', 'Warung Contoh', 'https://warung-contoh.example',
'https://warung-contoh.example/menu', '+62-21-0000-0000',
'Jl. Contoh Raya No. 1', 'Tangerang', 'Banten',
ARRAY['Indonesian'], 'Rp25.000-Rp75.000');
INSERT INTO menu_section (restaurant_id, name, position) VALUES
(1, 'Makanan Utama', 1),
(1, 'Minuman', 2);
INSERT INTO menu_item (section_id, name, description, price_idr, diet, position) VALUES
(1, 'Nasi Goreng Kampung', 'Nasi goreng bumbu terasi dengan telur ceplok', 28000, ARRAY['halal'], 1),
(1, 'Gado-Gado', 'Sayur rebus, tahu, tempe, lontong, dan bumbu kacang', 25000, ARRAY['vegetarian'], 2),
(2, 'Es Teh Manis', NULL, 8000, '{}', 1);
Catatan penting soal halal: isi nilai itu hanya kalau restoran memang memiliki sertifikat halal yang sah dan masih berlaku. Structured data adalah klaim publik, sama seperti tulisan di papan menu.
Langkah 2: Ambil Data Menu dalam Satu Bentuk yang Rapi
Repository kecil ini mengambil data restoran beserta seksi dan item yang masih tersedia, lalu menyusunnya menjadi struktur bertingkat. Semua konsumen data, mulai dari halaman, JSON-LD, sampai tes, memakai bentuk yang sama ini.
// src/menu-repo.js
export async function loadMenu(pool, slug) {
const r = await pool.query(
`SELECT id, slug, name, url, menu_url, telephone, street, locality,
region, postal_code, serves_cuisine, price_range
FROM restaurant
WHERE slug = $1`,
[slug]
);
if (r.rowCount === 0) return null;
const restaurant = r.rows[0];
const m = await pool.query(
`SELECT s.id AS section_id, s.name AS section_name,
i.id AS item_id, i.name AS item_name, i.description,
i.price_idr, i.diet
FROM menu_section s
LEFT JOIN menu_item i
ON i.section_id = s.id AND i.is_available
WHERE s.restaurant_id = $1
ORDER BY s.position, s.id, i.position, i.id`,
[restaurant.id]
);
const sections = [];
const byId = new Map();
for (const row of m.rows) {
let section = byId.get(row.section_id);
if (!section) {
section = { id: row.section_id, name: row.section_name, items: [] };
byId.set(row.section_id, section);
sections.push(section);
}
if (row.item_id !== null) {
section.items.push({
id: row.item_id,
name: row.item_name,
description: row.description,
priceIdr: row.price_idr,
diet: row.diet,
});
}
}
return { restaurant, sections };
}
Kondisi i.is_available saya taruh di klausa ON, bukan di WHERE. Kalau ditaruh di WHERE, seksi yang semua itemnya sedang nonaktif akan ikut hilang dari hasil query. Itu bukan masalah besar, tetapi menaruhnya di ON membuat perilakunya lebih mudah ditebak: seksi tetap terbaca, lalu seksi yang kosong disaring secara eksplisit di langkah berikutnya. Kolom text[] seperti diet dan serves_cuisine otomatis dikembalikan pg sebagai array JavaScript.
Langkah 3: Bangun JSON-LD Restaurant dengan hasMenu, MenuSection, dan MenuItem
Inilah inti dari json-ld restaurant hasmenu. Hierarkinya mengikuti schema.org: Restaurant punya hasMenu berisi Menu, Menu punya hasMenuSection, dan setiap MenuSection punya hasMenuItem. Harga ditaruh di objek Offer di dalam setiap MenuItem.
// src/jsonld.js
const DIET = {
halal: 'https://schema.org/HalalDiet',
vegetarian: 'https://schema.org/VegetarianDiet',
vegan: 'https://schema.org/VeganDiet',
gluten_free: 'https://schema.org/GlutenFreeDiet',
};
function toMenuItem(item) {
const menuItem = {
'@type': 'MenuItem',
name: item.name,
offers: {
'@type': 'Offer',
price: item.priceIdr,
priceCurrency: 'IDR',
},
};
if (item.description) menuItem.description = item.description;
const diets = item.diet.map((d) => DIET[d]).filter(Boolean);
if (diets.length > 0) menuItem.suitableForDiet = diets;
return menuItem;
}
export function buildRestaurantJsonLd({ restaurant, sections }) {
const address = {
'@type': 'PostalAddress',
streetAddress: restaurant.street,
addressLocality: restaurant.locality,
addressRegion: restaurant.region,
addressCountry: 'ID',
};
if (restaurant.postal_code) address.postalCode = restaurant.postal_code;
const jsonld = {
'@context': 'https://schema.org',
'@type': 'Restaurant',
'@id': `${restaurant.url}/#restaurant`,
name: restaurant.name,
url: restaurant.url,
telephone: restaurant.telephone,
address,
servesCuisine: restaurant.serves_cuisine,
menu: restaurant.menu_url,
hasMenu: {
'@type': 'Menu',
'@id': `${restaurant.menu_url}#menu`,
url: restaurant.menu_url,
inLanguage: 'id',
hasMenuSection: sections
.filter((s) => s.items.length > 0)
.map((s) => ({
'@type': 'MenuSection',
name: s.name,
hasMenuItem: s.items.map(toMenuItem),
})),
},
};
if (restaurant.price_range) jsonld.priceRange = restaurant.price_range;
return jsonld;
}
// Aman ditempel di dalam HTML: karakter "<" di-escape agar teks seperti
// "</script>" di deskripsi menu tidak menutup tag script lebih awal.
export function toScriptTag(jsonld) {
const json = JSON.stringify(jsonld).replace(/</g, '\\u003c');
return `<script type="application/ld+json">${json}</script>`;
}
Beberapa detail yang sering terlewat:
menudanhasMenudiisi keduanya. Di schema.org, propertimenusudah digantikanhasMenu, tetapi dokumentasi structured data local business dari Google masih menyebutmenusebagai URL halaman menu untuk usaha makanan. Mengisimenudengan URL danhasMenudengan struktur lengkap tidak saling bertabrakan.priceberupa angka, bukan teks berformat. Ini schema menuitem yang paling sering salah di klien saya."Rp28.000"atau"28.000"itu keliru. Di schema.org, titik adalah pemisah desimal, jadi28.000bisa terbaca sebagai dua puluh delapan. Tulis28000dan biarkanpriceCurrency: "IDR"yang menjelaskan mata uangnya.@idyang stabil. Dengan@id, entitas Restaurant di halaman menu bisa dirujuk sebagai entitas yang sama dengan markup LocalBusiness di halaman beranda, asalkan nilainya identik.- Seksi kosong dibuang.
MenuSectiontanpa item tidak memberi informasi apa pun. - Escape
<sebelum ditempel ke HTML. Deskripsi menu diketik oleh staf, dan suatu hari pasti ada yang menulis karakter aneh.<tetap terbaca sebagai<oleh parser JSON, tetapi tidak dianggap tag oleh browser.
Langkah 4: Endpoint Backend dan Halaman Menu dari Data yang Sama
Sekarang bagian yang membuat sinkronisasi terjadi secara otomatis: halaman menu yang terlihat pengunjung dan JSON-LD-nya dirender dari objek yang sama, dalam request yang sama. Kalau harga di database berubah, keduanya ikut berubah bersamaan.
// src/menu-page.js
import { buildRestaurantJsonLd, toScriptTag } from './jsonld.js';
const esc = (s) =>
String(s).replace(/[&<>"']/g, (c) => ({
'&': '&', '<': '<', '>': '>', '"': '"', "'": ''',
})[c]);
const rupiah = (n) => 'Rp' + n.toLocaleString('id-ID');
export function renderMenuPage(data) {
const { restaurant, sections } = data;
const jsonld = buildRestaurantJsonLd(data);
const body = sections
.filter((s) => s.items.length > 0)
.map((s) => `
<section>
<h2>${esc(s.name)}</h2>
<ul>
${s.items.map((i) => `
<li>
<strong>${esc(i.name)}</strong> ${rupiah(i.priceIdr)}
${i.description ? `<p>${esc(i.description)}</p>` : ''}
</li>`).join('')}
</ul>
</section>`)
.join('');
return `<!doctype html>
<html lang="id">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Menu ${esc(restaurant.name)}</title>
${toScriptTag(jsonld)}
</head>
<body>
<h1>Menu ${esc(restaurant.name)}</h1>
${body}
</body>
</html>`;
}
// server.js
import express from 'express';
import pg from 'pg';
import { loadMenu } from './src/menu-repo.js';
import { buildRestaurantJsonLd } from './src/jsonld.js';
import { renderMenuPage } from './src/menu-page.js';
const pool = new pg.Pool({ connectionString: process.env.DATABASE_URL });
const app = express();
// JSON-LD mentah, untuk frontend terpisah atau situs statis
app.get('/api/restaurants/:slug/jsonld', async (req, res, next) => {
try {
const data = await loadMenu(pool, req.params.slug);
if (!data) return res.status(404).json({ error: 'restaurant_not_found' });
res.set('Cache-Control', 'public, max-age=300');
res.type('application/ld+json').send(JSON.stringify(buildRestaurantJsonLd(data), null, 2));
} catch (err) {
next(err);
}
});
// Halaman menu lengkap: konten terlihat + JSON-LD dari data yang sama
app.get('/r/:slug/menu', async (req, res, next) => {
try {
const data = await loadMenu(pool, req.params.slug);
if (!data) return res.status(404).send('Menu tidak ditemukan');
res.set('Cache-Control', 'public, max-age=300');
res.type('html').send(renderMenuPage(data));
} catch (err) {
next(err);
}
});
app.listen(3000, () => console.log('Server jalan di http://localhost:3000'));
Jalankan dengan:
npm init -y && npm pkg set type=module
npm install express pg
DATABASE_URL=postgres://user:pass@localhost:5432/menu node server.js
curl -s http://localhost:3000/api/restaurants/warung-contoh/jsonld
Di produksi, route /r/:slug/menu biasanya dipetakan ke domain restoran sebagai /menu, sesuai nilai menu_url di database. Cache-Control lima menit adalah kompromi yang menurut saya wajar: perubahan harga terlihat dalam hitungan menit tanpa membebani database di setiap kunjungan. Kalau Anda memakai CDN, tambahkan purge cache setiap kali admin menyimpan perubahan menu.
Kalau websitenya situs statis, misalnya Astro, ambil JSON-LD dari endpoint saat build, lalu picu rebuild lewat deploy hook setiap kali menu disimpan:
---
// src/components/MenuSchema.astro
const res = await fetch(`${import.meta.env.MENU_API}/api/restaurants/warung-contoh/jsonld`);
if (!res.ok) throw new Error(`Gagal mengambil JSON-LD menu: ${res.status}`);
const jsonld = await res.json();
---
<script type="application/ld+json" set:html={JSON.stringify(jsonld).replace(/</g, '\\u003c')} />
Daftar menu yang terlihat di halaman juga harus diambil dari endpoint yang sama, misalnya dari endpoint JSON terpisah untuk data menu. Kalau JSON-LD datang dari API tetapi daftar menunya masih ditulis manual di file .astro, Anda hanya memindahkan masalahnya ke tempat lain. Build yang gagal saat API tidak bisa dihubungi juga disengaja. Lebih baik deploy tertunda daripada situs terbit dengan menu kosong.
Langkah 5: Kunci Pemetaan dengan Tes Otomatis
Structured data menu makanan rusak diam-diam: halaman tetap tampil normal, dan tidak ada pengunjung yang komplain. Karena itu saya minta setiap tim menambahkan tes kecil untuk fungsi pembangunnya. Test runner bawaan Node sudah cukup:
// test/jsonld.test.js
import test from 'node:test';
import assert from 'node:assert/strict';
import { buildRestaurantJsonLd, toScriptTag } from '../src/jsonld.js';
const data = {
restaurant: {
name: 'Warung Contoh',
url: 'https://warung-contoh.example',
menu_url: 'https://warung-contoh.example/menu',
telephone: '+62-21-0000-0000',
street: 'Jl. Contoh Raya No. 1',
locality: 'Tangerang',
region: 'Banten',
postal_code: null,
serves_cuisine: ['Indonesian'],
price_range: null,
},
sections: [
{
id: 1,
name: 'Makanan Utama',
items: [{ id: 2, name: 'Gado-Gado', description: null, priceIdr: 25000, diet: ['vegetarian'] }],
},
{ id: 2, name: 'Menu Musiman', items: [] },
],
};
test('harga, mata uang, dan diet terpetakan ke MenuItem', () => {
const ld = buildRestaurantJsonLd(data);
const sections = ld.hasMenu.hasMenuSection;
assert.equal(sections.length, 1); // seksi kosong dibuang
const item = sections[0].hasMenuItem[0];
assert.deepEqual(item.offers, { '@type': 'Offer', price: 25000, priceCurrency: 'IDR' });
assert.deepEqual(item.suitableForDiet, ['https://schema.org/VegetarianDiet']);
assert.equal('description' in item, false);
assert.equal('priceRange' in ld, false);
assert.equal('postalCode' in ld.address, false);
});
test('teks </script> di data tidak bisa menutup tag script', () => {
const tag = toScriptTag({ name: '</script><b>' });
const inner = tag.slice(0, -'</script>'.length);
assert.equal(inner.includes('</script>'), false);
});
Jalankan dengan node --test. Dua tes ini menangkap kesalahan yang paling mahal: harga yang berubah jadi string berformat, field kosong yang ikut terkirim sebagai null, dan HTML yang rusak gara-gara satu deskripsi menu.
Langkah 6: Validasi di Rich Results Test dan Schema Markup Validator
Validasi saya lakukan dalam urutan ini, dan masing-masing alat punya peran berbeda.
- Cek output mentah. Jalankan
curlke endpoint JSON-LD dan pastikan harga berupa angka, seksi kosong tidak ada, dan item nonaktif tidak muncul. - Schema Markup Validator (validator.schema.org). Alat ini memvalidasi seluruh kosakata schema.org, jadi di sinilah pohon
Menu,MenuSection, danMenuItemdiperiksa sampai keOfferdi dalamnya. Targetnya nol error. - Rich Results Test dari Google. Selama masih di lokal, Google tidak bisa mengakses
localhost, jadi pakai mode kode: jalankancurl -s http://localhost:3000/r/warung-contoh/menu, lalu tempel HTML-nya. Setelah deploy, uji URL halaman menu yang sebenarnya. BagianRestaurantumumnya terdeteksi sebagai data local business. Perlu diingat, Google saat ini tidak punya jenis rich result khusus menu, jadi jangan berharap muncul “menu” sebagai tipe tersendiri. Yang Anda pastikan di sini adalah tidak ada error dan Google bisa membaca halaman setelah dirender. - URL Inspection di Search Console setelah halaman live, untuk memastikan versi yang diindeks Google adalah versi terbaru, bukan versi cache lama.
- Cek silang manual. Ambil tiga item secara acak, lalu bandingkan harganya di halaman, di JSON-LD, dan di Google Business Profile. Lima menit ini sering menemukan hal yang tidak tertangkap alat apa pun.
Bedakan antara error dan warning. Error berarti markup tidak bisa dipakai dan wajib diperbaiki. Warning umumnya berarti ada properti opsional yang kosong, dan boleh diisi kalau datanya memang tersedia. Jangan mengarang data hanya supaya warning hilang.
Bonus: Daftar Perubahan untuk Google Business Profile
JSON-LD di website tidak otomatis memperbarui menu di Google Business Profile, jadi jangan berasumsi begitu. Menu di GBP diatur lewat dashboard GBP, dan Google juga bisa mengambil informasi dari sumber lain. Yang bisa kita lakukan adalah memastikan admin tahu persis apa saja yang berubah sejak terakhir kali GBP diperbarui. Kolom updated_at dan gbp_synced_at dari Langkah 1 dibuat untuk keperluan ini.
// tambahkan di server.js, dan lindungi dengan autentikasi admin
app.get('/api/restaurants/:slug/gbp-changes', async (req, res, next) => {
try {
const generatedAt = new Date().toISOString();
const { rows } = await pool.query(
`SELECT s.name AS section, i.name, i.price_idr, i.is_available, i.updated_at
FROM menu_item i
JOIN menu_section s ON s.id = i.section_id
JOIN restaurant r ON r.id = s.restaurant_id
WHERE r.slug = $1
AND i.updated_at > COALESCE(r.gbp_synced_at, '-infinity'::timestamptz)
ORDER BY i.updated_at`,
[req.params.slug]
);
res.json({ generatedAt, changes: rows });
} catch (err) {
next(err);
}
});
Alurnya untuk tim restoran:
- Admin membuka daftar perubahan. Item dengan
is_available: falseberarti harus disembunyikan atau dihapus di GBP, sedangkan item lain berarti harga atau namanya perlu diperbarui. - Admin menyalin perubahan ke editor menu di dashboard GBP.
- Setelah selesai, tandai sudah sinkron dengan nilai
generatedAtdari daftar tadi, bukannow(). Dengan begitu, perubahan yang masuk saat admin sedang bekerja tidak ikut dianggap sudah sinkron.
UPDATE restaurant SET gbp_synced_at = $2 WHERE slug = $1;
Proses ini memang masih manual, tetapi jauh lebih aman. Daftar perubahan dihasilkan oleh sistem, bukan dari ingatan kasir. Kalau perubahan nama seksi juga ingin dilacak, tambahkan kolom dan trigger updated_at yang sama di tabel menu_section.
Kesalahan yang Paling Sering Saya Temui
Sebagai rangkuman untuk SEO restoran lokal, ini daftar periksa yang saya pakai saat audit:
- Harga ditulis sebagai teks berformat (
"Rp28.000"). Seharusnya angka28000denganpriceCurrency: "IDR". - Markup memuat item yang tidak tampil di halaman. Kalau suatu menu tidak terlihat oleh pengunjung, jangan dimasukkan ke JSON-LD.
- Menu hanya berupa gambar. Tetap pasang foto menu kalau mau, tetapi daftar menu dalam bentuk teks HTML harus ada.
- Klaim diet tanpa dasar.
HalalDiethanya untuk restoran bersertifikat.VeganDiethanya kalau memang tidak ada bahan hewani sama sekali, termasuk dalam kaldu dan bumbunya. - Mencampur harga dine-in dan harga aplikasi. Pilih satu yang ditampilkan di website, lalu pastikan JSON-LD mengikutinya.
- Cache yang tidak pernah di-purge. Database sudah benar, tetapi CDN masih menyajikan halaman versi lama.
Penutup
Di Hari Pangan Sedunia ini, saya ingin mengingatkan bahwa banyak usaha kuliner lokal hidup dari pelanggan yang mencari “makan di dekat sini” lewat HP. Informasi menu dan harga yang keliru membuat calon pelanggan kecewa sebelum mereka datang. Schema markup menu restoran yang dihasilkan dari database bukan trik ranking. Ia adalah cara memastikan apa yang dibaca mesin pencari, apa yang dilihat pengunjung, dan apa yang tertera di Google Business Profile berasal dari satu sumber yang sama.
Urutan kerjanya, kalau Anda ingin mulai minggu ini:
- Pindahkan menu ke tiga tabel sederhana, dengan harga berupa integer dan
is_availablesebagai penggantiDELETE. - Buat satu fungsi
buildRestaurantJsonLddan kunci perilakunya dengan tes. - Render halaman menu dan JSON-LD dari objek data yang sama.
- Validasi di Schema Markup Validator dan Rich Results Test, lalu cek silang tiga item secara manual.
- Pakai daftar perubahan setiap kali GBP diperbarui.
Setelah itu, mengganti harga nasi goreng cukup dilakukan sekali, di satu tempat.
Ditulis oleh Doni Saputra