Build on Dineator

npm install @dineator/sdk

import { Dineator } from '@dineator/sdk';

const client = new Dineator({
  apiUrl: 'https://api.dineator.com',
  // Pass your JWT token after login
  token: 'your-jwt-token',
});

// POST /api/auth/login
const { data } = await client.auth.login({
  email: 'admin@myrestaurant.com',
  password: 'SecurePassword123!',
});

const token = data.accessToken;
// Store token — refresh at /api/auth/refresh using data.refreshToken

// Complete SDK source — also available at:
// https://github.com/dineator/js-sdk

class DineatorError extends Error {
  constructor(public status: number, public code: string, message: string) {
    super(message);
    this.name = 'DineatorError';
  }
}

class Dineator {
  private baseUrl: string;
  private token: string | null;

  constructor(opts: { apiUrl: string; token?: string }) {
    this.baseUrl = opts.apiUrl;
    this.token = opts.token ?? null;
  }

  setToken(token: string) { this.token = token; }

  private async request<T>(
    method: string, path: string, body?: unknown
  ): Promise<T> {
    const res = await fetch(`${this.baseUrl}${path}`, {
      method,
      headers: {
        'Content-Type': 'application/json',
        ...(this.token ? { Authorization: `Bearer ${this.token}` } : {}),
      },
      body: body ? JSON.stringify(body) : undefined,
    });
    const json = await res.json();
    if (!res.ok) throw new DineatorError(
      res.status, json.code ?? 'API_ERROR', json.message ?? 'Unknown error'
    );
    return json.data as T;
  }

  auth = {
    login: (body: { email: string; password: string }) =>
      this.request('POST', '/api/auth/login', body),
    refresh: (body: { refreshToken: string }) =>
      this.request('POST', '/api/auth/refresh', body),
    me: () => this.request('GET', '/api/auth/me'),
    logout: () => this.request('POST', '/api/auth/logout'),
    forgotPassword: (body: { email: string }) =>
      this.request('POST', '/api/auth/forgot-password', body),
  };

  menu = {
    getPublic: (slug: string) =>
      this.request('GET', `/api/menu/public/${slug}`),
    listCategories: () => this.request('GET', '/api/menu/categories'),
    createCategory: (body: object) =>
      this.request('POST', '/api/menu/categories', body),
    updateCategory: (id: string, body: object) =>
      this.request('PUT', `/api/menu/categories/${id}`, body),
    deleteCategory: (id: string) =>
      this.request('DELETE', `/api/menu/categories/${id}`),
    listItems: () => this.request('GET', '/api/menu/items'),
    createItem: (body: object) =>
      this.request('POST', '/api/menu/items', body),
    updateItem: (id: string, body: object) =>
      this.request('PUT', `/api/menu/items/${id}`, body),
    deleteItem: (id: string) =>
      this.request('DELETE', `/api/menu/items/${id}`),
  };

  orders = {
    placePublic: (slug: string, body: object) =>
      this.request('POST', `/api/orders/public/${slug}`, body),
    placeAdmin: (body: object) =>
      this.request('POST', '/api/orders/admin', body),
    list: () => this.request('GET', '/api/orders'),
    listKitchen: () => this.request('GET', '/api/orders/kitchen'),
    updateStatus: (id: string, body: object) =>
      this.request('PATCH', `/api/orders/${id}/status`, body),
    setKitchenItemReadiness: (orderId: string, itemId: string, ready: boolean) =>
      this.request('PATCH', `/api/orders/${orderId}/items/${itemId}/readiness`, { ready }),
    trackPublic: (orderId: string, secret: string) =>
      this.request('GET', `/api/orders/public/status/${orderId}?secret=${secret}`),
    appendItems: (orderId: string, body: object) =>
      this.request('PATCH', `/api/orders/${orderId}/append`, body),
    splitBill: (id: string, body: object) =>
      this.request('POST', `/api/orders/${id}/split`, body),
  };

  reservations = {
    create: (slug: string, body: object) =>
      this.request('POST', `/api/reservations/public/${slug}`, body),
    checkAvailability: (slug: string, params: object) => {
      const q = new URLSearchParams(params as Record<string,string>).toString();
      return this.request('GET', `/api/reservations/public/${slug}/availability?${q}`);
    },
    list: () => this.request('GET', '/api/reservations'),
    updateStatus: (id: string, body: object) =>
      this.request('PATCH', `/api/reservations/${id}/status`, body),
  };

  tables = {
    list: () => this.request('GET', '/api/tables'),
    create: (body: object) => this.request('POST', '/api/tables', body),
    update: (id: string, body: object) =>
      this.request('PUT', `/api/tables/${id}`, body),
    delete: (id: string) => this.request('DELETE', `/api/tables/${id}`),
  };

  analytics = {
    getDashboard: (params: { range: string }) => {
      const q = new URLSearchParams(params).toString();
      return this.request('GET', `/api/analytics/dashboard?${q}`);
    },
    export: (params: object) => {
      const q = new URLSearchParams(params as Record<string,string>).toString();
      return this.request('GET', `/api/analytics/export?${q}`);
    },
    refreshSnapshot: () =>
      this.request('POST', '/api/analytics/snapshot'),
  };

  theme = {
    get: (restaurantId: string) =>
      this.request('GET', `/api/restaurants/${restaurantId}/theme`),
    update: (restaurantId: string, body: object) =>
      this.request('PUT', `/api/restaurants/${restaurantId}/theme`, body),
    reset: (restaurantId: string) =>
      this.request('DELETE', `/api/restaurants/${restaurantId}/theme`),
  };

  promotions = {
    getActiveOffers: (restaurantId: string) =>
      this.request('GET', `/api/promotions/public/${restaurantId}/offers`),
    validateCoupon: (restaurantId: string, body: object) =>
      this.request('POST', `/api/promotions/public/${restaurantId}/validate-coupon`, body),
    listCoupons: () => this.request('GET', '/api/promotions/coupons'),
    createCoupon: (body: object) =>
      this.request('POST', '/api/promotions/coupons', body),
    updateCoupon: (id: string, body: object) =>
      this.request('PUT', `/api/promotions/coupons/${id}`, body),
    deleteCoupon: (id: string) =>
      this.request('DELETE', `/api/promotions/coupons/${id}`),
    listOffers: () => this.request('GET', '/api/promotions/offers'),
    createOffer: (body: object) =>
      this.request('POST', '/api/promotions/offers', body),
  };

  qr = {
    list: () => this.request('GET', '/api/qr'),
    generate: (body: object) => this.request('POST', '/api/qr/generate', body),
    delete: (id: string) => this.request('DELETE', `/api/qr/${id}`),
  };
}

// List all menu categories (authenticated)
const categories = await client.menu.listCategories();

// Get public menu (no auth required)
const publicMenu = await client.menu.getPublic('my-restaurant-slug');

// Create a category
const cat = await client.menu.createCategory({
  name: 'Starters',
  description: 'Delicious starters to begin your meal',
  sortOrder: 1,
});

// Create a menu item with modifiers
const item = await client.menu.createItem({
  name: 'Margherita Pizza',
  price: 12.99,
  categoryId: cat.id,
  isVeg: true,
  description: 'Classic tomato and mozzarella',
  variations: [
    { name: 'Small (8")', price: 9.99 },
    { name: 'Large (12")', price: 12.99 },
  ],
});

// Place a public order (no auth — called from customer storefront)
const order = await client.orders.placePublic('restaurant-slug', {
  tableId: 'table-uuid',          // optional for DINE_IN
  orderType: 'DINE_IN',           // 'DINE_IN' | 'TAKEAWAY' | 'DELIVERY'
  customerName: 'Jane Doe',
  items: [
    { menuItemId: 'item-uuid', quantity: 2, notes: 'No onions' },
  ],
});

// Staff: place admin order (bypasses business-hours check)
const adminOrder = await client.orders.placeAdmin({
  tableId: 'table-uuid',
  orderType: 'DINE_IN',
  items: [{ menuItemId: 'item-uuid', quantity: 1 }],
});

// Update order status
await client.orders.updateStatus('order-uuid', {
  status: 'PREPARING',
});

// List orders (with kitchen view)
const kitchenOrders = await client.orders.listKitchen();

// Create a public reservation (no auth)
const reservation = await client.reservations.create('restaurant-slug', {
  guestName: 'John Doe',
  guestPhone: '+1234567890',
  guestEmail: 'john@example.com',
  partySize: 4,
  reservationDate: '2026-06-15',
  reservationTime: '19:30',
  notes: 'Window seat preferred',
});

// Check availability (no auth)
const slots = await client.reservations.checkAvailability(
  'restaurant-slug',
  { date: '2026-06-15', partySize: 4 }
);

// Admin: update reservation status
await client.reservations.updateStatus('reservation-uuid', {
  status: 'CONFIRMED', // 'CONFIRMED' | 'CANCELLED' | 'COMPLETED'
});

// Get dashboard analytics (Manager+)
const dashboard = await client.analytics.getDashboard({
  range: '7d', // '1d' | '7d' | '30d' | '90d'
});

// Export as CSV (Manager+)
const csvBlob = await client.analytics.export({
  range: '30d',
  format: 'csv',
});

// Get theme for a restaurant (public)
const theme = await client.theme.get('restaurant-uuid');

// Update theme (Admin+)
await client.theme.update('restaurant-uuid', {
  tokens: {
    colors: {
      primary: '#1d4ed8',
      accent: '#f97316',
    },
    layout: {
      headerStyle: 'frosted',
      borderRadius: 'lg',
    },
  },
});

// Reset to the default colours and fonts (Admin+)
await client.theme.reset('restaurant-uuid');

// Get active offers (public)
const offers = await client.promotions.getActiveOffers('restaurant-uuid');

// Validate a coupon at checkout (public)
const coupon = await client.promotions.validateCoupon(
  'restaurant-uuid',
  { code: 'SAVE10', orderTotal: 45.00 }
);

// Admin: Create a coupon
await client.promotions.createCoupon({
  code: 'SUMMER20',
  discountType: 'PERCENTAGE',
  discountValue: 20,
  minOrderAmount: 30,
  maxUsages: 100,
  expiresAt: '2026-08-31T23:59:59Z',
});

// The SDK throws DineatorError on non-2xx responses
import { DineatorError } from '@dineator/sdk';

try {
  await client.menu.createItem({ /* ... */ });
} catch (err) {
  if (err instanceof DineatorError) {
    console.log(err.status);   // HTTP status code, e.g. 422
    console.log(err.code);     // API error code, e.g. "VALIDATION_ERROR"
    console.log(err.message);  // Human-readable message
  }
}