Github Repo 📃: DentalArt

GraqhQL API

In this part of our blog series, we'll dive into the heart of our Dental Clinic Management System - the database schema using GraphQL. We'll explore what GraphQL is, its advantages, and then proceed to explain the components of our schema. Let's get started! 🚀🦷

What is GraphQL?

GraphQL is a powerful query language for APIs, developed by Facebook. Unlike traditional REST APIs, where you make multiple requests for different endpoints, GraphQL allows clients to request exactly the data they need in a single query. It provides a flexible and efficient way to interact with your backend, making it a perfect fit for our Dental Clinic Management System.

Advantages of GraphQL

1. Efficiency: Clients can fetch only the required data, reducing unnecessary data transfers and improving performance.

2. Strong Typing: GraphQL schemas are strongly typed, ensuring type safety and reducing runtime errors.

3. Flexibility: The client has control over the data shape, enabling seamless updates to the frontend without server-side changes.

4. Multiple Data Sources: GraphQL allows aggregating data from various sources, making it ideal for complex applications like our Dental Clinic Management System.

Understanding the Schema

Now, let's break down the components of our GraphQL schema:

1. Tasks: Represents the tasks or errands assigned to staff members. It includes attributes like title, creation date, due date, details, and staff members associated with the task.

    type Tasks @model @auth(rules: [{allow: public}]) {
      id: ID!
      title: String
      date_created: AWSDateTime
      date_due: AWSDateTime
      details: String
      staff_assigned: [Staff] @manyToMany(relationName: "TasksStaff")
    }
   

2. Staff: Represents the clinic's staff members, including doctors, receptionists, nurses, and assistants. Each staff member has attributes like first name, last name, email, phone number, role, assigned appointments, and tasks.

    enum StaffRoleEnum {
      DOCTOR
      RECEPTIONIST
      NURSE
      NURSEAID
      ASSISTANT
    }
   
    type Staff @model @auth(rules: [{allow: public}]) {
      id: ID!
      first_name: String
      last_name: String
      email: AWSEmail
      username: String
      phone_number: AWSPhone
      role: StaffRoleEnum
      staff_appointments: [Appointments] @hasMany(indexName: "byStaff", fields: ["id"])
      taskss: [Tasks] @manyToMany(relationName: "TasksStaff")
    }
   

3. Appointments: Represents the scheduled appointments for patients. It includes attributes such as appointment date, start and end times, status (done, pending, missed, rescheduled), the staff member assigned to the appointment, and the patient ID associated with the appointment.

    enum AppointmentStatusEnum {
      DONE
      PENDING
      MISSED
      RESCHEDULED
    }
   
    type Appointments @model @auth(rules: [{allow: public}]) {
      id: ID!
      appointment_date: AWSDate
      created_at: AWSDateTime
      start_time: AWSTime
      end_time: AWSTime
      status: AppointmentStatusEnum
      assigned_to: String
      patientID: ID! @index(name: "byPatient")
      staffID: ID! @index(name: "byStaff")
    }
   

4. Patient: Represents the patients visiting the clinic. It includes attributes like first name, last name, email, date of birth, phone number, gender, and the appointments associated with each patient.

    type Patient @model @auth(rules: [{allow: public}]) {
      id: ID!
      first_name: String
      last_name: String
      email: AWSEmail
      date_of_birth: AWSDate
      phone_number: AWSPhone
      pat_appointments: [Appointments] @hasMany(indexName: "byPatient", fields: ["id"])
      gender: String
    }
   

Database Relationships

• Staff and Tasks have a many-to-many relationship, allowing tasks to be assigned to multiple staff members and vice versa.

• Staff and Appointments have a one-to-many relationship, where each staff member can be associated with multiple appointments.

• Patient and Appointments have a one-to-many relationship, allowing each patient to have multiple appointments.

GraphQL Resolvers

GraphQL resolvers are responsible for fetching data from the underlying data sources. In our case, AWS Amplify's GraphQL API will handle the resolvers, automatically managing data storage and retrieval from the database.

Data Access Control

With @auth rules defined in the schema, we ensure that specific parts of the data are protected and accessible only to authorized users. In our Dental Clinic Management System, we'll allow public access to appointments, staff, tasks, and patients while restricting sensitive information access as needed.

By adopting this well-designed GraphQL schema, our Dental Clinic Management System will efficiently manage appointments, tasks, staff, and patients, providing a seamless experience for both the clinic staff and the patients.

In the next part of our series, we'll dive into the implementation details of building our GraphQL API and connecting it with AWS Amplify. Stay tuned, as we move closer to bringing our Dental Clinic Management System to life! 😄🏥🦷

Feel free to share your thoughts and questions in the comments below. Happy coding! 💻🎉

#AWSAmplif #AWSAmplifyHackathon