API Documentation

MD Services Training Management Platform — developer reference

Overview

The API layer is organized into three modules accessible from @/api: entity CRUD wrappers (api/entities.js), backend function wrappers (api/functions.js), and React Query hooks (api/hooks.js). All data operations go through the pre-initialized Base44 SDK client.

import { courseApi, feedbackApi, useCourses, useAllFeedback, functionsApi, authApi } from "@/api";

Entities & CRUD Operations

Each entity exposes the following operations:

list

list(sort?, limit?)

List all records

get

get(id)

Get a single record by ID

filter

filter(query, sort?, limit?)

Filter records by query

create

create(data)

Create a new record

update

update(id, data)

Update a record

delete

delete(id)

Delete a record

bulkCreate

bulkCreate(data[])

Create multiple records

bulkUpdate

bulkUpdate(data[])

Update multiple records by ID

updateMany

updateMany(query, $set|$unset|$inc…)

Update all matching records

deleteMany

deleteMany(query)

Delete all matching records

Course

Training course catalog entries

title

stringrequired

category

enum: eusr_cscs | wja | mdsrequired

description

string

format

enum: classroom | online | remote

duration_value

number

duration_unit

enum: hours | daysdefault: hours

max_capacity

number

price

number (GBP)

image_url

string

location_id

string (Location ref)

location_name

string

scheduled_dates

array[{ start_date, finish_date, label }]

date_tbc

boolean

is_published

boolean

certification

string

certification_period

string

key_training_aspects

string

target_audience

string

training_content_areas

string

candidate_requirements

string

course_examination

string

notes

string

availability_status

enum: available | limited | full | coming_soon | cancelleddefault: available

List courses (sorted)

import { courseApi } from "@/api";

const courses = await courseApi.list("-created_date", 50);

Filter sessions

import { sessionApi } from "@/api";

const upcoming = await sessionApi.filter(
  { status: "scheduled" },
  "start_date",
  100
);

Create a trainer

import { trainerApi } from "@/api";

const trainer = await trainerApi.create({
  full_name: "Jane Smith",
  email: "jane@example.com",
  specialisations: "First Aid, WHS",
});

Backend Functions

Invoked via functionsApi.<name>(payload) — returns response.data directly.

Function

Auth

Payload

Description

getPublicCourses

→ { courses, sessions, locations }

Public

—

Returns all published courses, upcoming sessions, and active locations for the public portal.

getUsers

→ { users: User[] }

Admin

—

Lists all registered site users. Admin-only.

getAccessRequests

→ { accessRequests: AccessRequest[] }

Admin

—

Lists all access requests. Admin-only.

submitAccessRequest

→ { accessRequest }

Public

{ full_name, email, phone?, company?, reason? }

Creates or updates a public access request. Enriches name/email from auth token if available.

processAccessRequest

→ { success, status }

Admin

{ requestId, action: 'approve' | 'deny' }

Approves (invites user) or denies a pending access request. Admin-only.

inviteCourseBooker

→ { success }

Admin

{ full_name, email, organisation, phone? }

Invites a new course booker, sets their role and organisation, and sends a branded welcome email. Admin-only.

createAndRegisterUsers

→ { results: { invited, registered, emailsSent, errors } }

Admin

{ newUsers?: [{full_name, email}], existingUserIds?: string[], sessionId }

Creates/invites new trainees and/or registers existing users into a session, sending confirmation emails.

generateCertificates

→ { count, certificates }

Admin

{ sessionId }

Generates PDF certificates for completed registrations in a session and uploads them. Admin-only.

notifyWaitlist

System

{ session_id }

Notifies the next waitlisted trainee when a spot opens on a session.

notifySessionFull

System

entity automation (session data)

Sends an alert to admins when a session reaches maximum capacity.

sendSessionReminders

System

—

Sends 3-day reminder emails to registered trainees for upcoming sessions. Runs on a schedule.

updateUserActivity

→ { success }

Authenticated

—

Updates the current user's last_activity timestamp for presence tracking.

Invoke a backend function

import { functionsApi } from "@/api";

const data = await functionsApi.getPublicCourses();
// → { courses, sessions, locations }

const result = await functionsApi.createAndRegisterUsers({
  newUsers: [{ full_name: "John Doe", email: "john@example.com" }],
  sessionId: "session_123",
});

React Query Hooks

Pre-built hooks with centralized query keys and automatic cache invalidation. Import from @/api.

Hook

Returns

Query Key

useCourses(){ data: Course[] }["courses"]

useSessions(sort, limit){ data: TrainingSession[] }["sessions"]

useScheduledSessions(){ data: TrainingSession[] }["sessions-bulk"]

useTrainers(){ data: Trainer[] }["trainers"]

useLocations(){ data: Location[] }["locations"]

useActiveLocations(){ data: Location[] }["locations"]

useRegistrations(){ data: Registration[] }["registrations"]

useRegisteredRegistrations(){ data: Registration[] }["registrations-bulk"]

useUsers(){ data: User[] }["users"]

useAccessRequests(){ data: AccessRequest[] }["access-requests"]

usePublicCourses(){ data: {courses, sessions, locations} }["public-courses"]

useCourseMutations(){ create, update, delete }—

useSessionMutations(){ create, update, delete }—

useTrainerMutations(){ create, update, delete }—

useLocationMutations(){ create, update, delete }—

useAccessRequestMutations(){ approve, deny, submit }—

useGenerateCertificates()mutation—

useAllFeedback(){ data: Feedback[] }["feedback"]

useMyFeedback(userId){ data: Feedback[] }["feedback", userId]

useFeedbackMutations(){ create }—

Using hooks in a component

import { useCourses, useSessionMutations } from "@/api";

function MyComponent() {
  const { data: courses = [], isLoading } = useCourses();
  const { create, update, delete: del } = useSessionMutations();

  const handleCreate = (data) =>
    create.mutate(data, {
      onSuccess: () => toast.success("Session created"),
    });
}

Authentication

Auth operations via authApi. The platform owns the auth backend (tokens, sessions, email verification).

me

Get the current authenticated user

updateMe

Update current user profile data

isAuthenticated

Check if a session is active (returns Promise<boolean>)

logout

Log out and optionally redirect

redirectToLogin

Redirect to the login page

Built-in Fields

Every entity record includes these fields automatically — never declared in schemas:

idUnique record identifier

created_dateAuto-set creation timestamp

updated_dateAuto-updated on modification

created_by_idID of the user who created the record