Krow/Krow-workspace
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Integrate Data Connect and Implement Staff List View Directory

Browse Source
This commit is contained in:
dhinesh-m24
2026-01-31 16:54:59 +05:30
parent 48bb1c457c
commit cb25b33d04
255 changed files with 21425 additions and 109 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
apps/web/dataconnect/connector/account/mutations.gql Normal file
View File

@@ -0,0 +1,51 @@
mutation createAccount(
$bank: String!
$type: AccountType!
$last4: String!
$isPrimary: Boolean
$ownerId: UUID!
$accountNumber: String
$routeNumber: String
$expiryTime: Timestamp
) @auth(level: USER) {
account_insert(
data: {
bank: $bank
type: $type
last4: $last4
isPrimary: $isPrimary
ownerId: $ownerId
accountNumber: $accountNumber
routeNumber: $routeNumber
expiryTime: $expiryTime
}
)
}
mutation updateAccount(
$id: UUID!
$bank: String
$type: AccountType
$last4: String
$isPrimary: Boolean
$accountNumber: String
$routeNumber: String
$expiryTime: Timestamp
) @auth(level: USER) {
account_update(
id: $id
data: {
bank: $bank
type: $type
last4: $last4
isPrimary: $isPrimary
accountNumber: $accountNumber
routeNumber: $routeNumber
expiryTime: $expiryTime
}
)
}
mutation deleteAccount($id: UUID!) @auth(level: USER) {
account_delete(id: $id)
}

70
apps/web/dataconnect/connector/account/queries.gql Normal file
View File

@@ -0,0 +1,70 @@
query listAccounts @auth(level: USER) {
accounts {
id
bank
type
last4
isPrimary
ownerId
accountNumber
routeNumber
expiryTime
createdAt
}
}
query getAccountById($id: UUID!) @auth(level: USER) {
account(id: $id) {
id
bank
type
last4
isPrimary
ownerId
accountNumber
routeNumber
expiryTime
createdAt
}
}
query getAccountsByOwnerId($ownerId: UUID!) @auth(level: USER) {
accounts(where: { ownerId: { eq: $ownerId } }) {
id
bank
type
last4
isPrimary
ownerId
accountNumber
routeNumber
expiryTime
createdAt
}
}
query filterAccounts(
$bank: String
$type: AccountType
$isPrimary: Boolean
$ownerId: UUID
) @auth(level: USER) {
accounts(
where: {
bank: { eq: $bank }
type: { eq: $type }
isPrimary: { eq: $isPrimary }
ownerId: { eq: $ownerId }
}
) {
id
bank
type
last4
isPrimary
ownerId
accountNumber
expiryTime
routeNumber
}
}

96
apps/web/dataconnect/connector/activityLog/mutations.gql Normal file
View File

@@ -0,0 +1,96 @@
mutation createActivityLog(
$userId: String!
$date: Timestamp!
$hourStart: String
$hourEnd: String
$totalhours: String
$iconType: ActivityIconType
$iconColor: String
$title: String!
$description: String!
$isRead: Boolean
$activityType: ActivityType!
) @auth(level: USER) {
activityLog_insert(
data: {
userId: $userId
date: $date
hourStart: $hourStart
hourEnd: $hourEnd
totalhours: $totalhours
iconType: $iconType
iconColor: $iconColor
title: $title
description: $description
isRead: $isRead
activityType: $activityType
}
)
}
mutation updateActivityLog(
$id: UUID!
$userId: String
$date: Timestamp
$hourStart: String
$hourEnd: String
$totalhours: String
$iconType: ActivityIconType
$iconColor: String
$title: String
$description: String
$isRead: Boolean
$activityType: ActivityType
) @auth(level: USER) {
activityLog_update(
id: $id
data: {
userId: $userId
date: $date
hourStart: $hourStart
hourEnd: $hourEnd
totalhours: $totalhours
iconType: $iconType
iconColor: $iconColor
title: $title
description: $description
isRead: $isRead
activityType: $activityType
}
)
}
# ----------------------------------------------------------
# MARK AS READ (single)
# ----------------------------------------------------------
mutation markActivityLogAsRead($id: UUID!) @auth(level: USER) {
activityLog_update(
id: $id
data: { isRead: true }
)
}
# ----------------------------------------------------------
# MARK MANY AS READ (correct op name in your DC)
# ----------------------------------------------------------
mutation markActivityLogsAsRead(
$ids: [UUID!]!
) @auth(level: USER) {
activityLog_updateMany(
where: { id: { in: $ids } }
data: { isRead: true }
)
}
mutation deleteActivityLog($id: UUID!) @auth(level: USER) {
activityLog_delete(id: $id)
}

175
apps/web/dataconnect/connector/activityLog/queries.gql Normal file
View File

@@ -0,0 +1,175 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listActivityLogs(
$offset: Int
$limit: Int
) @auth(level: USER) {
activityLogs(offset: $offset, limit: $limit) {
id
userId
date
hourStart
hourEnd
totalhours
iconType
iconColor
title
description
isRead
activityType
createdAt
updatedAt
createdBy
}
}
# ----------------------------------------------------------
# GET BY ID
# ----------------------------------------------------------
query getActivityLogById($id: UUID!) @auth(level: USER) {
activityLog(id: $id) {
id
userId
date
hourStart
hourEnd
totalhours
iconType
iconColor
title
description
isRead
activityType
createdAt
updatedAt
createdBy
}
}
# ----------------------------------------------------------
# LIST BY USER
# ----------------------------------------------------------
query listActivityLogsByUserId(
$userId: String!
$offset: Int
$limit: Int
) @auth(level: USER) {
activityLogs(
where: { userId: { eq: $userId } }
offset: $offset
limit: $limit
orderBy: { date: DESC }
) {
id
userId
date
hourStart
hourEnd
totalhours
iconType
iconColor
title
description
isRead
activityType
createdAt
updatedAt
createdBy
}
}
# ----------------------------------------------------------
# LIST UNREAD BY USER (common for notifications UI)
# ----------------------------------------------------------
query listUnreadActivityLogsByUserId(
$userId: String!
$offset: Int
$limit: Int
) @auth(level: USER) {
activityLogs(
where: {
userId: { eq: $userId }
isRead: { eq: false }
}
offset: $offset
limit: $limit
orderBy: { date: DESC }
) {
id
userId
date
hourStart
hourEnd
totalhours
iconType
iconColor
title
description
isRead
activityType
createdAt
updatedAt
createdBy
}
}
# ----------------------------------------------------------
# FILTER (user + date range + read status + type)
# NOTE: Timestamp filter uses ge/le (NOT gte/lte)
# ----------------------------------------------------------
query filterActivityLogs(
$userId: String
$dateFrom: Timestamp
$dateTo: Timestamp
$isRead: Boolean
$activityType: ActivityType
$iconType: ActivityIconType
$offset: Int
$limit: Int
) @auth(level: USER) {
activityLogs(
where: {
userId: { eq: $userId }
date: { ge: $dateFrom, le: $dateTo }
isRead: { eq: $isRead }
activityType: { eq: $activityType }
iconType: { eq: $iconType }
}
offset: $offset
limit: $limit
orderBy: { date: DESC }
) {
id
userId
date
hourStart
hourEnd
totalhours
iconType
iconColor
title
description
isRead
activityType
createdAt
updatedAt
createdBy
}
}

47
apps/web/dataconnect/connector/application/mutations.gql Normal file
View File

@@ -0,0 +1,47 @@
mutation createApplication(
$shiftId: UUID!
$staffId: UUID!
$status: ApplicationStatus!
$checkInTime: Timestamp
$checkOutTime: Timestamp
$origin: ApplicationOrigin!
$roleId: UUID!
) @auth(level: USER) {
application_insert(
data: {
shiftId: $shiftId
staffId: $staffId
status: $status
checkInTime: $checkInTime
checkOutTime: $checkOutTime
origin: $origin
roleId: $roleId
}
)
}
mutation updateApplicationStatus(
$id: UUID!
$shiftId: UUID
$staffId: UUID
$status: ApplicationStatus
$checkInTime: Timestamp
$checkOutTime: Timestamp
$roleId: UUID!
) @auth(level: USER) {
application_update(
id: $id
data: {
shiftId: $shiftId
staffId: $staffId
status: $status
checkInTime: $checkInTime
checkOutTime: $checkOutTime
roleId: $roleId
}
)
}
mutation deleteApplication($id: UUID!) @auth(level: USER) {
application_delete(id: $id)
}

403
apps/web/dataconnect/connector/application/queries.gql Normal file
View File

@@ -0,0 +1,403 @@
query listApplications @auth(level: USER) {
applications {
id
shiftId
staffId
status
appliedAt
checkInTime
checkOutTime
origin
createdAt
shift {
id
title
date
startTime
endTime
location
status
order {
id
eventName
location
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
shiftRole {
id
roleId
count
assigned
startTime
endTime
hours
totalValue
role {
id
name
costPerHour
}
}
}
}
query getApplicationById($id: UUID!) @auth(level: USER) {
application(id: $id) {
id
shiftId
staffId
status
appliedAt
checkInTime
checkOutTime
origin
createdAt
shift {
id
title
date
startTime
endTime
location
status
order {
id
eventName
location
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
shiftRole {
id
roleId
count
assigned
startTime
endTime
hours
totalValue
role {
id
name
costPerHour
}
}
}
}
query getApplicationsByShiftId($shiftId: UUID!) @auth(level: USER) {
applications(where: { shiftId: { eq: $shiftId } }) {
id
shiftId
staffId
status
appliedAt
checkInTime
checkOutTime
origin
createdAt
shift {
id
title
date
startTime
endTime
location
status
order {
id
eventName
location
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
shiftRole {
id
roleId
count
assigned
startTime
endTime
hours
totalValue
role {
id
name
costPerHour
}
}
}
}
query getApplicationsByShiftIdAndStatus(
$shiftId: UUID!
$status: ApplicationStatus!
$offset: Int
$limit: Int
) @auth(level: USER) {
applications(
where: {
shiftId: { eq: $shiftId }
status: { eq: $status }
}
offset: $offset
limit: $limit
) {
id
shiftId
staffId
status
appliedAt
checkInTime
checkOutTime
origin
createdAt
shift {
id
title
date
startTime
endTime
location
status
order {
id
eventName
location
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
shiftRole {
id
roleId
count
assigned
startTime
endTime
hours
totalValue
role {
id
name
costPerHour
}
}
}
}
query getApplicationsByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
applications(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
) {
id
shiftId
staffId
status
appliedAt
checkInTime
checkOutTime
origin
createdAt
shift {
id
title
date
startTime
endTime
location
status
order {
id
eventName
location
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
shiftRole {
id
roleId
count
assigned
startTime
endTime
hours
totalValue
role {
id
name
costPerHour
}
}
}
}
#getting staffs of an shiftrole ACCEPTED for orders view client
query listAcceptedApplicationsByShiftRoleKey(
$shiftId: UUID!
$roleId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
applications(
where: {
shiftId: { eq: $shiftId }
roleId: { eq: $roleId }
status: { eq: ACCEPTED }
}
offset: $offset
limit: $limit
orderBy: { appliedAt: ASC }
) {
id
checkInTime
checkOutTime
staff { id fullName email phone photoUrl }
}
}
#getting staffs of an shiftrole ACCEPTED for orders of the day view client
query listAcceptedApplicationsByBusinessForDay(
$businessId: UUID!
$dayStart: Timestamp!
$dayEnd: Timestamp!
$offset: Int
$limit: Int
) @auth(level: USER) {
applications(
where: {
status: { eq: ACCEPTED }
shift: {
date: { ge: $dayStart, le: $dayEnd }
order: { businessId: { eq: $businessId } }
}
}
offset: $offset
limit: $limit
orderBy: { appliedAt: ASC }
) {
id
shiftId
roleId
checkInTime
checkOutTime
appliedAt
staff { id fullName email phone photoUrl }
}
}
#coverage list and today live
query listStaffsApplicationsByBusinessForDay(
$businessId: UUID!
$dayStart: Timestamp!
$dayEnd: Timestamp!
$offset: Int
$limit: Int
) @auth(level: USER) {
applications(
where: {
status: {in: [ACCEPTED, CONFIRMED, CHECKED_IN, CHECKED_OUT, LATE]}
shift: {
date: { ge: $dayStart, le: $dayEnd }
order: { businessId: { eq: $businessId } }
#status: { eq: ACCEPTED }
}
}
offset: $offset
limit: $limit
orderBy: { appliedAt: ASC }
) {
id
shiftId
roleId
checkInTime
checkOutTime
appliedAt
status
shiftRole{
shift{
location
cost
}
count
assigned
role{
name
}
}
staff { id fullName email phone photoUrl }
}
}

71
apps/web/dataconnect/connector/assignment/mutations.gql Normal file
View File

@@ -0,0 +1,71 @@
mutation CreateAssignment(
$workforceId: UUID!
$title: String
$description: String
$instructions: String
$status: AssignmentStatus
$tipsAvailable: Boolean
$travelTime: Boolean
$mealProvided: Boolean
$parkingAvailable: Boolean
$gasCompensation: Boolean
$managers: [Any!]
$roleId: UUID!
$shiftId: UUID!
) @auth(level: USER) {
assignment_insert(
data: {
workforceId: $workforceId
title: $title
description: $description
instructions: $instructions
status: $status
tipsAvailable: $tipsAvailable
travelTime: $travelTime
mealProvided: $mealProvided
parkingAvailable: $parkingAvailable
gasCompensation: $gasCompensation
managers: $managers
roleId: $roleId
shiftId: $shiftId
}
)
}
mutation UpdateAssignment(
$id: UUID!
$title: String
$description: String
$instructions: String
$status: AssignmentStatus
$tipsAvailable: Boolean
$travelTime: Boolean
$mealProvided: Boolean
$parkingAvailable: Boolean
$gasCompensation: Boolean
$managers: [Any!]
$roleId: UUID!
$shiftId: UUID!
) @auth(level: USER) {
assignment_update(
id: $id
data: {
title: $title
description: $description
instructions: $instructions
status: $status
tipsAvailable: $tipsAvailable
travelTime: $travelTime
mealProvided: $mealProvided
parkingAvailable: $parkingAvailable
gasCompensation: $gasCompensation
managers: $managers
roleId: $roleId
shiftId: $shiftId
}
)
}
mutation DeleteAssignment($id: UUID!) @auth(level: USER) {
assignment_delete(id: $id)
}

278
apps/web/dataconnect/connector/assignment/queries.gql Normal file
View File

@@ -0,0 +1,278 @@
# ------------------------------------------------------------
# LIST ALL ASSIGNMENTS (admin/debug)
# ------------------------------------------------------------
query listAssignments(
$offset: Int
$limit: Int
) @auth(level: USER) {
assignments(offset: $offset, limit: $limit) {
id
title
status
createdAt
workforce {
id
workforceNumber
staff { id fullName }
}
shiftRole {
id
count
assigned
startTime
endTime
hours
totalValue
role { id name costPerHour }
shift {
id
title
date
location
locationAddress
latitude
longitude
status
order {
id
eventName
business { id businessName email contactName }
vendor { id companyName }
}
}
}
}
}
# ------------------------------------------------------------
# GET ASSIGNMENT BY ID
# ------------------------------------------------------------
query getAssignmentById($id: UUID!) @auth(level: USER) {
assignment(id: $id) {
id
title
description
instructions
status
tipsAvailable
travelTime
mealProvided
parkingAvailable
gasCompensation
managers
createdAt
updatedAt
createdBy
workforce {
id
workforceNumber
status
staff { id fullName }
}
shiftRole {
id
startTime
endTime
hours
totalValue
breakType
uniform
department
role { id name costPerHour }
shift {
id
title
date
location
locationAddress
latitude
longitude
status
managers
order {
id
eventName
orderType
business { id businessName email contactName }
vendor { id companyName }
}
}
}
}
}
# ------------------------------------------------------------
# MY ASSIGNMENTS (by workforceId) - Staff view
# ------------------------------------------------------------
query listAssignmentsByWorkforceId(
$workforceId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
assignments(
where: { workforceId: { eq: $workforceId } }
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
id
title
status
createdAt
workforce {
id
workforceNumber
staff { id fullName }
}
shiftRole {
id
startTime
endTime
hours
totalValue
role { id name costPerHour }
shift {
id
title
date
location
status
order {
id
eventName
business { id businessName }
vendor { id companyName }
}
}
}
}
}
# ------------------------------------------------------------
# ASSIGNMENTS FOR A VENDOR (Vendor dashboard)
# Approach: filter by workforce.vendorId (relation)
# If Data Connect can't filter nested, use 2-step:
# 1) listWorkforceByVendorId => workforce ids
# 2) assignments(where: { workforceId: { in: [...] } })
# ------------------------------------------------------------
query listAssignmentsByWorkforceIds(
$workforceIds: [UUID!]!
$offset: Int
$limit: Int
) @auth(level: USER) {
assignments(
where: { workforceId: { in: $workforceIds } }
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
id
title
status
createdAt
workforce { id workforceNumber staff { id fullName } }
shiftRole {
id
role { id name }
shift {
id
title
date
order {
id
eventName
business { id businessName }
vendor { id companyName }
}
}
}
}
}
# ------------------------------------------------------------
# ASSIGNMENTS BY SHIFT ROLE (useful for staffing)
# ------------------------------------------------------------
query listAssignmentsByShiftRole(
$shiftId: UUID!
$roleId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
assignments(
where: {
shiftId: { eq: $shiftId }
roleId: { eq: $roleId }
}
offset: $offset
limit: $limit
) {
id
title
status
createdAt
workforce { id workforceNumber staff { id fullName } }
}
}
# ------------------------------------------------------------
# FILTER ASSIGNMENTS (status + date range)
# Date range is based on Shift.date through the relation (NOT filterable directly).
#
# Since ShiftRole uses a composite key (shiftId + roleId),
# Assignments must be filtered using BOTH fields.
#
# So the filtering flow is:
# 1) Get Shifts in the date range => shiftIds
# 2) Get ShiftRoles where shiftId IN shiftIds => (shiftId, roleId) pairs
# 3) Get Assignments where:
# - shiftId matches
# - roleId matches
# - status matches (optional)
#
# This query represents step 3.
# ------------------------------------------------------------
query filterAssignments(
$shiftIds: [UUID!]!
$roleIds: [UUID!]!
$status: AssignmentStatus
$offset: Int
$limit: Int
) @auth(level: USER) {
assignments(
where: {
shiftId: { in: $shiftIds }
roleId: { in: $roleIds }
status: { eq: $status }
}
offset: $offset
limit: $limit
) {
id
title
status
createdAt
workforce { id workforceNumber staff { id fullName } }
shiftRole {
id
role { id name }
shift { id title date location status }
}
}
}

45
apps/web/dataconnect/connector/attireOption/mutations.gql Normal file
View File

@@ -0,0 +1,45 @@
mutation createAttireOption(
$itemId: String!
$label: String!
$icon: String
$imageUrl: String
$isMandatory: Boolean
$vendorId: UUID
) @auth(level: USER) {
attireOption_insert(
data: {
itemId: $itemId
label: $label
icon: $icon
imageUrl: $imageUrl
isMandatory: $isMandatory
vendorId: $vendorId
}
)
}
mutation updateAttireOption(
$id: UUID!
$itemId: String
$label: String
$icon: String
$imageUrl: String
$isMandatory: Boolean
$vendorId: UUID
) @auth(level: USER) {
attireOption_update(
id: $id
data: {
itemId: $itemId
label: $label
icon: $icon
imageUrl: $imageUrl
isMandatory: $isMandatory
vendorId: $vendorId
}
)
}
mutation deleteAttireOption($id: UUID!) @auth(level: USER) {
attireOption_delete(id: $id)
}

47
apps/web/dataconnect/connector/attireOption/queries.gql Normal file
View File

@@ -0,0 +1,47 @@
query listAttireOptions @auth(level: USER) {
attireOptions {
id
itemId
label
icon
imageUrl
isMandatory
vendorId
createdAt
}
}
query getAttireOptionById($id: UUID!) @auth(level: USER) {
attireOption(id: $id) {
id
itemId
label
icon
imageUrl
isMandatory
vendorId
createdAt
}
}
query filterAttireOptions(
$itemId: String
$isMandatory: Boolean
$vendorId: UUID
) @auth(level: USER) {
attireOptions(
where: {
itemId: { eq: $itemId }
isMandatory: { eq: $isMandatory }
vendorId: { eq: $vendorId }
}
) {
id
itemId
label
icon
imageUrl
isMandatory
vendorId
}
}

36
apps/web/dataconnect/connector/benefitsData/mutations.gql Normal file
View File

@@ -0,0 +1,36 @@
mutation createBenefitsData(
$vendorBenefitPlanId: UUID!
$staffId: UUID!
$current: Int!
) @auth(level: USER) {
benefitsData_insert(
data: {
vendorBenefitPlanId: $vendorBenefitPlanId
staffId: $staffId
current: $current
}
)
}
mutation updateBenefitsData(
$staffId: UUID!
$vendorBenefitPlanId: UUID!
$current: Int
) @auth(level: USER) {
benefitsData_update(
key: { staffId: $staffId, vendorBenefitPlanId: $vendorBenefitPlanId }
data: {
current: $current
}
)
}
mutation deleteBenefitsData(
$staffId: UUID!
$vendorBenefitPlanId: UUID!
) @auth(level: USER) {
benefitsData_delete(
key: { staffId: $staffId, vendorBenefitPlanId: $vendorBenefitPlanId }
)
}

165
apps/web/dataconnect/connector/benefitsData/queries.gql Normal file
View File

@@ -0,0 +1,165 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listBenefitsData(
$offset: Int
$limit: Int
) @auth(level: USER) {
benefitsDatas(offset: $offset, limit: $limit) {
id
vendorBenefitPlanId
current
staffId
staff {
id
fullName
}
vendorBenefitPlan {
id
vendorId
title
description
requestLabel
total
isActive
}
}
}
# ----------------------------------------------------------
# GET BY KEY (staffId + vendorBenefitPlanId) ✅ (replaces getById in practice)
# ----------------------------------------------------------
query getBenefitsDataByKey(
$staffId: UUID!
$vendorBenefitPlanId: UUID!
) @auth(level: USER) {
benefitsData(key: { staffId: $staffId, vendorBenefitPlanId: $vendorBenefitPlanId }) {
id
vendorBenefitPlanId
current
staffId
staff {
id
fullName
}
vendorBenefitPlan {
id
vendorId
title
description
requestLabel
total
isActive
}
}
}
# ----------------------------------------------------------
# LIST BY STAFF
# ----------------------------------------------------------
query listBenefitsDataByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
benefitsDatas(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
) {
id
vendorBenefitPlanId
current
staffId
staff {
id
fullName
}
vendorBenefitPlan {
id
vendorId
title
description
requestLabel
total
isActive
}
}
}
# ----------------------------------------------------------
# LIST BY VENDOR BENEFIT PLAN
# ----------------------------------------------------------
query listBenefitsDataByVendorBenefitPlanId(
$vendorBenefitPlanId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
benefitsDatas(
where: { vendorBenefitPlanId: { eq: $vendorBenefitPlanId } }
offset: $offset
limit: $limit
) {
id
vendorBenefitPlanId
current
staffId
staff {
id
fullName
}
vendorBenefitPlan {
id
vendorId
title
description
requestLabel
total
isActive
}
}
}
# ----------------------------------------------------------
# LIST BY VENDOR (2-step helper: planIds -> benefitsDatas IN)
# ----------------------------------------------------------
query listBenefitsDataByVendorBenefitPlanIds(
$vendorBenefitPlanIds: [UUID!]!
$offset: Int
$limit: Int
) @auth(level: USER) {
benefitsDatas(
where: { vendorBenefitPlanId: { in: $vendorBenefitPlanIds } }
offset: $offset
limit: $limit
) {
id
vendorBenefitPlanId
current
staffId
staff {
id
fullName
}
vendorBenefitPlan {
id
vendorId
title
description
requestLabel
total
isActive
}
}
}

75
apps/web/dataconnect/connector/business/mutations.gql Normal file
View File

@@ -0,0 +1,75 @@
mutation createBusiness(
$businessName: String!,
$contactName: String,
$userId: String!,
$companyLogoUrl: String,
$phone: String,
$email: String,
$hubBuilding: String,
$address: String,
$city: String,
$area: BusinessArea,
$sector: BusinessSector,
$rateGroup: BusinessRateGroup!,
$status: BusinessStatus!,
$notes: String
) @auth(level: USER) {
business_insert(
data: {
businessName: $businessName,
contactName: $contactName,
userId: $userId,
companyLogoUrl: $companyLogoUrl,
phone: $phone,
email: $email,
hubBuilding: $hubBuilding,
address: $address,
city: $city,
area: $area,
sector: $sector,
rateGroup: $rateGroup,
status: $status,
notes: $notes
}
)
}
mutation updateBusiness(
$id: UUID!,
$businessName: String,
$contactName: String,
$companyLogoUrl: String,
$phone: String,
$email: String,
$hubBuilding: String,
$address: String,
$city: String,
$area: BusinessArea,
$sector: BusinessSector,
$rateGroup: BusinessRateGroup,
$status: BusinessStatus,
$notes: String
) @auth(level: USER) {
business_update(
id: $id,
data: {
businessName: $businessName,
contactName: $contactName,
companyLogoUrl: $companyLogoUrl,
phone: $phone,
email: $email,
hubBuilding: $hubBuilding,
address: $address,
city: $city,
area: $area,
sector: $sector,
rateGroup: $rateGroup,
status: $status,
notes: $notes
}
)
}
mutation deleteBusiness($id: UUID!) @auth(level: USER) {
business_delete(id: $id)
}

65
apps/web/dataconnect/connector/business/queries.gql Normal file
View File

@@ -0,0 +1,65 @@
query listBusinesses @auth(level: USER) {
businesses {
id
businessName
contactName
userId
companyLogoUrl
phone
email
hubBuilding
address
city
area
sector
rateGroup
status
notes
createdAt
updatedAt
}
}
query getBusinessesByUserId($userId: String!) @auth(level: USER) {
businesses(where: { userId: { eq: $userId } }) {
id
businessName
contactName
userId
companyLogoUrl
phone
email
hubBuilding
address
city
area
sector
rateGroup
status
notes
createdAt
updatedAt
}
}
query getBusinessById($id: UUID!) @auth(level: USER) {
business(id: $id) {
id
businessName
contactName
userId
companyLogoUrl
phone
email
hubBuilding
address
city
area
sector
rateGroup
status
notes
createdAt
updatedAt
}
}

34
apps/web/dataconnect/connector/category/mutations.gql Normal file
View File

@@ -0,0 +1,34 @@
mutation createCategory(
$categoryId: String!
$label: String!
$icon: String
) @auth(level: USER) {
category_insert(
data: {
categoryId: $categoryId
label: $label
icon: $icon
}
)
}
mutation updateCategory(
$id: UUID!
$categoryId: String
$label: String
$icon: String
) @auth(level: USER) {
category_update(
id: $id
data: {
categoryId: $categoryId
label: $label
icon: $icon
}
)
}
mutation deleteCategory($id: UUID!) @auth(level: USER) {
category_delete(id: $id)
}

43
apps/web/dataconnect/connector/category/queries.gql Normal file
View File

@@ -0,0 +1,43 @@
query listCategories @auth(level: USER) {
categories {
id
categoryId
label
icon
createdAt
updatedAt
createdBy
}
}
query getCategoryById($id: UUID!) @auth(level: USER) {
category(id: $id) {
id
categoryId
label
icon
createdAt
updatedAt
createdBy
}
}
query filterCategories(
$categoryId: String
$label: String
) @auth(level: USER) {
categories(
where: {
categoryId: { eq: $categoryId }
label: { eq: $label }
}
) {
id
categoryId
label
icon
createdAt
updatedAt
createdBy
}
}

65
apps/web/dataconnect/connector/certificate/mutations.gql Normal file
View File

@@ -0,0 +1,65 @@
mutation CreateCertificate(
$name: String!
$description: String
$expiry: Timestamp
$status: CertificateStatus!
$fileUrl: String
$icon: String
$certificationType: ComplianceType
$issuer: String
$staffId: UUID!
$validationStatus: ValidationStatus
$certificateNumber: String
) @auth(level: USER) {
certificate_insert(
data: {
name: $name
description: $description
expiry: $expiry
status: $status
fileUrl: $fileUrl
icon: $icon
staffId: $staffId
certificationType: $certificationType
issuer: $issuer
validationStatus: $validationStatus
certificateNumber: $certificateNumber
}
)
}
mutation UpdateCertificate(
$id: UUID!
$name: String
$description: String
$expiry: Timestamp
$status: CertificateStatus
$fileUrl: String
$icon: String
$staffId: UUID
$certificationType: ComplianceType
$issuer: String
$validationStatus: ValidationStatus
$certificateNumber: String
) @auth(level: USER) {
certificate_update(
id: $id
data: {
name: $name
description: $description
expiry: $expiry
status: $status
fileUrl: $fileUrl
icon: $icon
staffId: $staffId
certificationType: $certificationType
issuer: $issuer
validationStatus: $validationStatus
certificateNumber: $certificateNumber
}
)
}
mutation DeleteCertificate($id: UUID!) @auth(level: USER) {
certificate_delete(id: $id)
}

72
apps/web/dataconnect/connector/certificate/queries.gql Normal file
View File

@@ -0,0 +1,72 @@
query listCertificates @auth(level: USER) {
certificates {
id
name
description
expiry
status
fileUrl
icon
staffId
certificationType
issuer
validationStatus
certificateNumber
createdAt
staff {
id
fullName
}
}
}
query getCertificateById($id: UUID!) @auth(level: USER) {
certificate(id: $id) {
id
name
description
expiry
status
fileUrl
icon
certificationType
issuer
staffId
validationStatus
certificateNumber
updatedAt
staff {
id
fullName
}
}
}
query listCertificatesByStaffId($staffId: UUID!) @auth(level: USER) {
certificates(where: { staffId: { eq: $staffId } }) {
id
name
description
expiry
status
fileUrl
icon
staffId
certificationType
issuer
validationStatus
certificateNumber
createdAt
staff {
id
fullName
}
}
}

43
apps/web/dataconnect/connector/clientFeedback/mutations.gql Normal file
View File

@@ -0,0 +1,43 @@
mutation createClientFeedback(
$businessId: UUID!
$vendorId: UUID!
$rating: Int
$comment: String
$date: Timestamp
$createdBy: String
) @auth(level: USER) {
clientFeedback_insert(
data: {
businessId: $businessId
vendorId: $vendorId
rating: $rating
comment: $comment
date: $date
}
)
}
mutation updateClientFeedback(
$id: UUID!
$businessId: UUID
$vendorId: UUID
$rating: Int
$comment: String
$date: Timestamp
$createdBy: String
) @auth(level: USER) {
clientFeedback_update(
id: $id
data: {
businessId: $businessId
vendorId: $vendorId
rating: $rating
comment: $comment
date: $date
}
)
}
mutation deleteClientFeedback($id: UUID!) @auth(level: USER) {
clientFeedback_delete(id: $id)
}

185
apps/web/dataconnect/connector/clientFeedback/queries.gql Normal file
View File

@@ -0,0 +1,185 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listClientFeedbacks(
$offset: Int
$limit: Int
) @auth(level: USER) {
clientFeedbacks(offset: $offset, limit: $limit) {
id
businessId
vendorId
rating
comment
date
createdAt
business { id businessName }
vendor { id companyName }
}
}
# ----------------------------------------------------------
# GET BY ID
# ----------------------------------------------------------
query getClientFeedbackById($id: UUID!) @auth(level: USER) {
clientFeedback(id: $id) {
id
businessId
vendorId
rating
comment
date
createdAt
business { id businessName }
vendor { id companyName }
}
}
# ----------------------------------------------------------
# LIST BY BUSINESS
# ----------------------------------------------------------
query listClientFeedbacksByBusinessId(
$businessId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
clientFeedbacks(
where: { businessId: { eq: $businessId } }
offset: $offset
limit: $limit
orderBy: { date: DESC }
) {
id
businessId
vendorId
rating
comment
date
createdAt
business { id businessName }
vendor { id companyName }
}
}
# ----------------------------------------------------------
# LIST BY VENDOR
# ----------------------------------------------------------
query listClientFeedbacksByVendorId(
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
clientFeedbacks(
where: { vendorId: { eq: $vendorId } }
offset: $offset
limit: $limit
orderBy: { date: DESC }
) {
id
businessId
vendorId
rating
comment
date
createdAt
business { id businessName }
vendor { id companyName }
}
}
# ----------------------------------------------------------
# LIST BY BUSINESS + VENDOR (pair)
# ----------------------------------------------------------
query listClientFeedbacksByBusinessAndVendor(
$businessId: UUID!
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
clientFeedbacks(
where: {
businessId: { eq: $businessId }
vendorId: { eq: $vendorId }
}
offset: $offset
limit: $limit
orderBy: { date: DESC }
) {
id
businessId
vendorId
rating
comment
date
createdAt
business { id businessName }
vendor { id companyName }
}
}
# ----------------------------------------------------------
# FILTER (rating + date range)
# NOTE: using Timestamp ops: ge/le
# ----------------------------------------------------------
query filterClientFeedbacks(
$businessId: UUID
$vendorId: UUID
$ratingMin: Int
$ratingMax: Int
$dateFrom: Timestamp
$dateTo: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
clientFeedbacks(
where: {
businessId: { eq: $businessId }
vendorId: { eq: $vendorId }
rating: { ge: $ratingMin, le: $ratingMax }
date: { ge: $dateFrom, le: $dateTo }
}
offset: $offset
limit: $limit
orderBy: { date: DESC }
) {
id
businessId
vendorId
rating
comment
date
business { id businessName }
vendor { id companyName }
}
}
# ----------------------------------------------------------
# QUICK KPI: average rating for a vendor (client-side aggregate)
# You fetch rows; Flutter/web computes avg.
# ----------------------------------------------------------
query listClientFeedbackRatingsByVendorId(
$vendorId: UUID!
$dateFrom: Timestamp
$dateTo: Timestamp
) @auth(level: USER) {
clientFeedbacks(
where: {
vendorId: { eq: $vendorId }
date: { ge: $dateFrom, le: $dateTo }
}
orderBy: { date: DESC }
) {
id
rating
comment
date
business { id businessName }
vendor { id companyName }
}
}

5
apps/web/dataconnect/connector/connector.yaml Normal file
View File

@@ -0,0 +1,5 @@
connectorId: example
generate:
dartSdk:
- outputDir: ../../../apps/mobile/packages/data_connect/lib/src/dataconnect_generated
package: dataconnect_generated/generated.dart

69
apps/web/dataconnect/connector/conversation/mutations.gql Normal file
View File

@@ -0,0 +1,69 @@
mutation createConversation(
$subject: String
$status: ConversationStatus
$conversationType: ConversationType
$isGroup: Boolean
$groupName: String
$lastMessage: String
$lastMessageAt: Timestamp
) @auth(level: USER) {
conversation_insert(
data: {
subject: $subject
status: $status
conversationType: $conversationType
isGroup: $isGroup
groupName: $groupName
lastMessage: $lastMessage
lastMessageAt: $lastMessageAt
}
)
}
mutation updateConversation(
$id: UUID!
$subject: String
$status: ConversationStatus
$conversationType: ConversationType
$isGroup: Boolean
$groupName: String
$lastMessage: String
$lastMessageAt: Timestamp
) @auth(level: USER) {
conversation_update(
id: $id
data: {
subject: $subject
status: $status
conversationType: $conversationType
isGroup: $isGroup
groupName: $groupName
lastMessage: $lastMessage
lastMessageAt: $lastMessageAt
}
)
}
# ----------------------------------------------------------
# UPDATE LAST MESSAGE
# ----------------------------------------------------------
mutation updateConversationLastMessage(
$id: UUID!
$lastMessage: String
$lastMessageAt: Timestamp
) @auth(level: USER) {
conversation_update(
id: $id
data: {
lastMessage: $lastMessage
lastMessageAt: $lastMessageAt
}
)
}
mutation deleteConversation($id: UUID!) @auth(level: USER) {
conversation_delete(id: $id)
}

125
apps/web/dataconnect/connector/conversation/queries.gql Normal file
View File

@@ -0,0 +1,125 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listConversations(
$offset: Int
$limit: Int
) @auth(level: USER) {
conversations(offset: $offset, limit: $limit, orderBy: { updatedAt: DESC }) {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
}
# ----------------------------------------------------------
# GET BY ID
# ----------------------------------------------------------
query getConversationById($id: UUID!) @auth(level: USER) {
conversation(id: $id) {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
}
# ----------------------------------------------------------
# LIST BY TYPE (CLIENT_VENDOR / GROUP_STAFF)
# ----------------------------------------------------------
query listConversationsByType(
$conversationType: ConversationType!
$offset: Int
$limit: Int
) @auth(level: USER) {
conversations(
where: { conversationType: { eq: $conversationType } }
offset: $offset
limit: $limit
orderBy: { lastMessageAt: DESC }
) {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
}
# ----------------------------------------------------------
# LIST BY STATUS (ACTIVE)
# ----------------------------------------------------------
query listConversationsByStatus(
$status: ConversationStatus!
$offset: Int
$limit: Int
) @auth(level: USER) {
conversations(
where: { status: { eq: $status } }
offset: $offset
limit: $limit
orderBy: { lastMessageAt: DESC }
) {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
}
# ----------------------------------------------------------
# FILTER (dashboard/debug)
# Supports searching by multiple optional fields
# ----------------------------------------------------------
query filterConversations(
$status: ConversationStatus
$conversationType: ConversationType
$isGroup: Boolean
$lastMessageAfter: Timestamp
$lastMessageBefore: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
conversations(
where: {
status: { eq: $status }
conversationType: { eq: $conversationType }
isGroup: { eq: $isGroup }
lastMessageAt: { ge: $lastMessageAfter, le: $lastMessageBefore }
}
offset: $offset
limit: $limit
orderBy: { lastMessageAt: DESC }
) {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
}

53
apps/web/dataconnect/connector/course/mutations.gql Normal file
View File

@@ -0,0 +1,53 @@
mutation createCourse(
$title: String
$description: String
$thumbnailUrl: String
$durationMinutes: Int
$xpReward: Int
$categoryId: UUID!
$levelRequired: String
$isCertification: Boolean
) @auth(level: USER) {
course_insert(
data: {
title: $title
description: $description
thumbnailUrl: $thumbnailUrl
durationMinutes: $durationMinutes
xpReward: $xpReward
categoryId: $categoryId
levelRequired: $levelRequired
isCertification: $isCertification
}
)
}
mutation updateCourse(
$id: UUID!
$title: String
$description: String
$thumbnailUrl: String
$durationMinutes: Int
$xpReward: Int
$categoryId: UUID!
$levelRequired: String
$isCertification: Boolean
) @auth(level: USER) {
course_update(
id: $id
data: {
title: $title
description: $description
thumbnailUrl: $thumbnailUrl
durationMinutes: $durationMinutes
xpReward: $xpReward
categoryId: $categoryId
levelRequired: $levelRequired
isCertification: $isCertification
}
)
}
mutation deleteCourse($id: UUID!) @auth(level: USER) {
course_delete(id: $id)
}

68
apps/web/dataconnect/connector/course/queries.gql Normal file
View File

@@ -0,0 +1,68 @@
query listCourses @auth(level: USER) {
courses {
id
title
description
thumbnailUrl
durationMinutes
xpReward
categoryId
levelRequired
isCertification
createdAt
category{
id
label
}
}
}
query getCourseById($id: UUID!) @auth(level: USER) {
course(id: $id) {
id
title
description
thumbnailUrl
durationMinutes
xpReward
categoryId
levelRequired
isCertification
createdAt
category{
id
label
}
}
}
query filterCourses(
$categoryId: UUID
$isCertification: Boolean
$levelRequired: String
$completed: Boolean
) @auth(level: USER) {
courses(
where: {
categoryId: { eq: $categoryId }
isCertification: { eq: $isCertification }
levelRequired: { eq: $levelRequired }
}
) {
id
title
categoryId
levelRequired
isCertification
category{
id
label
}
}
}

37
apps/web/dataconnect/connector/customRateCard/mutations.gql Normal file
View File

@@ -0,0 +1,37 @@
mutation createCustomRateCard(
$name: String!,
$baseBook: String,
$discount: Float,
$isDefault: Boolean
) @auth(level: USER) {
customRateCard_insert(
data: {
name: $name,
baseBook: $baseBook,
discount: $discount,
isDefault: $isDefault
}
)
}
mutation updateCustomRateCard(
$id: UUID!,
$name: String,
$baseBook: String,
$discount: Float,
$isDefault: Boolean
) @auth(level: USER) {
customRateCard_update(
id: $id,
data: {
name: $name,
baseBook: $baseBook,
discount: $discount,
isDefault: $isDefault
}
)
}
mutation deleteCustomRateCard($id: UUID!) @auth(level: USER) {
customRateCard_delete(id: $id)
}

23
apps/web/dataconnect/connector/customRateCard/queries.gql Normal file
View File

@@ -0,0 +1,23 @@
query listCustomRateCards @auth(level: USER) {
customRateCards {
id
name
baseBook
discount
isDefault
createdAt
updatedAt
}
}
query getCustomRateCardById($id: UUID!) @auth(level: USER) {
customRateCard(id: $id) {
id
name
baseBook
discount
isDefault
createdAt
updatedAt
}
}

33
apps/web/dataconnect/connector/document/mutations.gql Normal file
View File

@@ -0,0 +1,33 @@
mutation createDocument(
$documentType: DocumentType!
$name: String!
$description: String
) @auth(level: USER) {
document_insert(
data: {
documentType: $documentType
name: $name
description: $description
}
)
}
mutation updateDocument(
$id: UUID!
$documentType: DocumentType
$name: String
$description: String
) @auth(level: USER) {
document_update(
id: $id
data: {
documentType: $documentType
name: $name
description: $description
}
)
}
mutation deleteDocument($id: UUID!) @auth(level: USER) {
document_delete(id: $id)
}

35
apps/web/dataconnect/connector/document/queries.gql Normal file
View File

@@ -0,0 +1,35 @@
query listDocuments @auth(level: USER) {
documents {
id
documentType
name
description
createdAt
}
}
query getDocumentById($id: UUID!) @auth(level: USER) {
document(id: $id) {
id
documentType
name
description
createdAt
}
}
query filterDocuments(
$documentType: DocumentType
) @auth(level: USER) {
documents(
where: {
documentType: { eq: $documentType }
}
) {
id
documentType
name
description
createdAt
}
}

35
apps/web/dataconnect/connector/emergencyContact/mutations.gql Normal file
View File

@@ -0,0 +1,35 @@
mutation createEmergencyContact(
$name: String!
$phone: String!
$relationship: RelationshipType!
$staffId: UUID!
) @auth(level: USER) {
emergencyContact_insert(
data: {
name: $name
phone: $phone
relationship: $relationship
staffId: $staffId
}
)
}
mutation updateEmergencyContact(
$id: UUID!
$name: String
$phone: String
$relationship: RelationshipType
) @auth(level: USER) {
emergencyContact_update(
id: $id
data: {
name: $name
phone: $phone
relationship: $relationship
}
)
}
mutation deleteEmergencyContact($id: UUID!) @auth(level: USER) {
emergencyContact_delete(id: $id)
}

38
apps/web/dataconnect/connector/emergencyContact/queries.gql Normal file
View File

@@ -0,0 +1,38 @@
query listEmergencyContacts @auth(level: USER) {
emergencyContacts {
id
name
phone
relationship
staffId
createdAt
updatedAt
createdBy
}
}
query getEmergencyContactById($id: UUID!) @auth(level: USER) {
emergencyContact(id: $id) {
id
name
phone
relationship
staffId
createdAt
updatedAt
createdBy
}
}
query getEmergencyContactsByStaffId($staffId: UUID!) @auth(level: USER) {
emergencyContacts(where: { staffId: { eq: $staffId } }) {
id
name
phone
relationship
staffId
createdAt
updatedAt
createdBy
}
}

29
apps/web/dataconnect/connector/faqData/mutations.gql Normal file
View File

@@ -0,0 +1,29 @@
mutation createFaqData(
$category: String!
$questions: [Any!]
) @auth(level: USER) {
faqData_insert(
data: {
category: $category
questions: $questions
}
)
}
mutation updateFaqData(
$id: UUID!
$category: String
$questions: [Any!]
) @auth(level: USER) {
faqData_update(
id: $id
data: {
category: $category
questions: $questions
}
)
}
mutation deleteFaqData($id: UUID!) @auth(level: USER) {
faqData_delete(id: $id)
}

29
apps/web/dataconnect/connector/faqData/queries.gql Normal file
View File

@@ -0,0 +1,29 @@
query listFaqDatas @auth(level: USER) {
faqDatas {
id
category
questions
createdAt
updatedAt
createdBy
}
}
query getFaqDataById($id: UUID!) @auth(level: USER) {
faqData(id: $id) {
id
category
questions
createdAt
updatedAt
createdBy
}
}
query filterFaqDatas($category: String) @auth(level: USER) {
faqDatas(where: { category: { eq: $category } }) {
id
category
questions
}
}

41
apps/web/dataconnect/connector/hub/mutations.gql Normal file
View File

@@ -0,0 +1,41 @@
mutation createHub(
$name: String!
$locationName: String
$address: String
$nfcTagId: String
$ownerId: UUID!
) @auth(level: USER) {
hub_insert(
data: {
name: $name
locationName: $locationName
address: $address
nfcTagId: $nfcTagId
ownerId: $ownerId
}
)
}
mutation updateHub(
$id: UUID!
$name: String
$locationName: String
$address: String
$nfcTagId: String
$ownerId: UUID
) @auth(level: USER) {
hub_update(
id: $id
data: {
name: $name
locationName: $locationName
address: $address
nfcTagId: $nfcTagId
ownerId: $ownerId
}
)
}
mutation deleteHub($id: UUID!) @auth(level: USER) {
hub_delete(id: $id)
}

62
apps/web/dataconnect/connector/hub/queries.gql Normal file
View File

@@ -0,0 +1,62 @@
query listHubs @auth(level: USER) {
hubs {
id
name
locationName
address
nfcTagId
ownerId
createdAt
updatedAt
createdBy
}
}
query getHubById($id: UUID!) @auth(level: USER) {
hub(id: $id) {
id
name
locationName
address
nfcTagId
ownerId
createdAt
updatedAt
createdBy
}
}
query getHubsByOwnerId($ownerId: UUID!) @auth(level: USER) {
hubs(where: { ownerId: { eq: $ownerId } }) {
id
name
locationName
address
nfcTagId
ownerId
createdAt
updatedAt
createdBy
}
}
query filterHubs(
$ownerId: UUID
$name: String
$nfcTagId: String
) @auth(level: USER) {
hubs(
where: {
ownerId: { eq: $ownerId }
name: { eq: $name }
nfcTagId: { eq: $nfcTagId }
}
) {
id
name
locationName
address
nfcTagId
ownerId
}
}

123
apps/web/dataconnect/connector/invoice/mutations.gql Normal file
View File

@@ -0,0 +1,123 @@
mutation createInvoice(
$status: InvoiceStatus!
$vendorId: UUID!
$businessId: UUID!
$orderId: UUID!
$paymentTerms: InovicePaymentTerms
$invoiceNumber: String!
$issueDate: Timestamp!
$dueDate: Timestamp!
$hub: String
$managerName: String
$vendorNumber: String
$roles: Any
$charges: Any
$otherCharges: Float
$subtotal: Float
$amount: Float!
$notes: String
$staffCount: Int
$chargesCount: Int
) @auth(level: USER) {
invoice_insert(
data: {
status: $status
vendorId: $vendorId
businessId: $businessId
orderId: $orderId
paymentTerms: $paymentTerms
invoiceNumber: $invoiceNumber
issueDate: $issueDate
dueDate: $dueDate
hub: $hub
managerName: $managerName
vendorNumber: $vendorNumber
roles: $roles
charges: $charges
otherCharges: $otherCharges
subtotal: $subtotal
amount: $amount
notes: $notes
staffCount: $staffCount
chargesCount: $chargesCount
}
)
}
mutation updateInvoice(
$id: UUID!
$status: InvoiceStatus
$vendorId: UUID
$businessId: UUID
$orderId: UUID
$paymentTerms: InovicePaymentTerms
$invoiceNumber: String
$issueDate: Timestamp
$dueDate: Timestamp
$hub: String
$managerName: String
$vendorNumber: String
$roles: Any
$charges: Any
$otherCharges: Float
$subtotal: Float
$amount: Float
$notes: String
$staffCount: Int
$chargesCount: Int
$disputedItems: Any
$disputeReason: String
$disputeDetails: String
) @auth(level: USER) {
invoice_update(
id: $id
data: {
status: $status
vendorId: $vendorId
businessId: $businessId
orderId: $orderId
paymentTerms: $paymentTerms
invoiceNumber: $invoiceNumber
issueDate: $issueDate
dueDate: $dueDate
hub: $hub
managerName: $managerName
vendorNumber: $vendorNumber
roles: $roles
charges: $charges
otherCharges: $otherCharges
subtotal: $subtotal
amount: $amount
notes: $notes
staffCount: $staffCount
chargesCount: $chargesCount
disputedItems: $disputedItems
disputeReason: $disputeReason
disputeDetails: $disputeDetails
}
)
}
mutation deleteInvoice($id: UUID!) @auth(level: USER) {
invoice_delete(id: $id)
}

520
apps/web/dataconnect/connector/invoice/queries.gql Normal file
View File

@@ -0,0 +1,520 @@
# ------------------------------------------------------------
# LIST ALL INVOICES (admin/debug)
# ------------------------------------------------------------
query listInvoices(
$offset: Int
$limit: Int
) @auth(level: USER) {
invoices(offset: $offset, limit: $limit) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}
# ------------------------------------------------------------
# GET INVOICE BY ID
# ------------------------------------------------------------
query getInvoiceById($id: UUID!) @auth(level: USER) {
invoice(id: $id) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}
# ------------------------------------------------------------
# LIST INVOICES BY VENDOR
# ------------------------------------------------------------
query listInvoicesByVendorId(
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoices(
where: { vendorId: { eq: $vendorId } }
offset: $offset
limit: $limit
orderBy: { issueDate: DESC }
) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}
# ------------------------------------------------------------
# LIST INVOICES BY BUSINESS
# ------------------------------------------------------------
query listInvoicesByBusinessId(
$businessId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoices(
where: { businessId: { eq: $businessId } }
offset: $offset
limit: $limit
orderBy: { issueDate: DESC }
) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}
# ------------------------------------------------------------
# LIST INVOICES BY ORDER
# ------------------------------------------------------------
query listInvoicesByOrderId(
$orderId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoices(
where: { orderId: { eq: $orderId } }
offset: $offset
limit: $limit
orderBy: { issueDate: DESC }
) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}
# ------------------------------------------------------------
# LIST INVOICES BY STATUS
# ------------------------------------------------------------
query listInvoicesByStatus(
$status: InvoiceStatus!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoices(
where: { status: { eq: $status } }
offset: $offset
limit: $limit
orderBy: { dueDate: ASC }
) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}
# ------------------------------------------------------------
# FILTER INVOICES (multi filters)
# NOTE: Timestamp filters use ge/le (NOT gte/lte)
# ------------------------------------------------------------
query filterInvoices(
$vendorId: UUID
$businessId: UUID
$orderId: UUID
$status: InvoiceStatus
$issueDateFrom: Timestamp
$issueDateTo: Timestamp
$dueDateFrom: Timestamp
$dueDateTo: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
invoices(
where: {
vendorId: { eq: $vendorId }
businessId: { eq: $businessId }
orderId: { eq: $orderId }
status: { eq: $status }
issueDate: { ge: $issueDateFrom, le: $issueDateTo }
dueDate: { ge: $dueDateFrom, le: $dueDateTo }
}
offset: $offset
limit: $limit
orderBy: { issueDate: DESC }
) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}
# ------------------------------------------------------------
# OVERDUE INVOICES (dueDate < now and not PAID)
# NOTE: request.time works in @default; for filters, pass $now from client
# ------------------------------------------------------------
query listOverdueInvoices(
$now: Timestamp!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoices(
where: {
dueDate: { lt: $now }
status: { ne: PAID }
}
offset: $offset
limit: $limit
orderBy: { dueDate: ASC }
) {
id
status
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
disputedItems
disputeReason
disputeDetails
vendor {
companyName
address
email
phone
}
business {
businessName
address
phone
email
}
order {
eventName
hub
deparment
poReference
}
}
}

115
apps/web/dataconnect/connector/invoiceTemplate/mutations.gql Normal file
View File

@@ -0,0 +1,115 @@
mutation createInvoiceTemplate(
$name: String!
$ownerId: UUID!
$vendorId: UUID
$businessId: UUID
$orderId: UUID
$paymentTerms: InovicePaymentTermsTemp
$invoiceNumber: String
$issueDate: Timestamp
$dueDate: Timestamp
$hub: String
$managerName: String
$vendorNumber: String
$roles: Any
$charges: Any
$otherCharges: Float
$subtotal: Float
$amount: Float
$notes: String
$staffCount: Int
$chargesCount: Int
) @auth(level: USER) {
invoiceTemplate_insert(
data: {
name: $name
ownerId: $ownerId
vendorId: $vendorId
businessId: $businessId
orderId: $orderId
paymentTerms: $paymentTerms
invoiceNumber: $invoiceNumber
issueDate: $issueDate
dueDate: $dueDate
hub: $hub
managerName: $managerName
vendorNumber: $vendorNumber
roles: $roles
charges: $charges
otherCharges: $otherCharges
subtotal: $subtotal
amount: $amount
notes: $notes
staffCount: $staffCount
chargesCount: $chargesCount
}
)
}
mutation updateInvoiceTemplate(
$id: UUID!
$name: String
$ownerId: UUID
$vendorId: UUID
$businessId: UUID
$orderId: UUID
$paymentTerms: InovicePaymentTermsTemp
$invoiceNumber: String
$issueDate: Timestamp
$dueDate: Timestamp
$hub: String
$managerName: String
$vendorNumber: String
$roles: Any
$charges: Any
$otherCharges: Float
$subtotal: Float
$amount: Float
$notes: String
$staffCount: Int
$chargesCount: Int
) @auth(level: USER) {
invoiceTemplate_update(
id: $id
data: {
name: $name
ownerId: $ownerId
vendorId: $vendorId
businessId: $businessId
orderId: $orderId
paymentTerms: $paymentTerms
invoiceNumber: $invoiceNumber
issueDate: $issueDate
dueDate: $dueDate
hub: $hub
managerName: $managerName
vendorNumber: $vendorNumber
roles: $roles
charges: $charges
otherCharges: $otherCharges
subtotal: $subtotal
amount: $amount
notes: $notes
staffCount: $staffCount
chargesCount: $chargesCount
}
)
}
mutation deleteInvoiceTemplate($id: UUID!) @auth(level: USER) {
invoiceTemplate_delete(id: $id)
}

325
apps/web/dataconnect/connector/invoiceTemplate/queries.gql Normal file
View File

@@ -0,0 +1,325 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listInvoiceTemplates(
$offset: Int
$limit: Int
) @auth(level: USER) {
invoiceTemplates(offset: $offset, limit: $limit) {
id
name
ownerId
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
createdAt
updatedAt
createdBy
vendor { id companyName }
business { id businessName email contactName }
order { id eventName status orderType }
}
}
# ----------------------------------------------------------
# GET BY ID
# ----------------------------------------------------------
query getInvoiceTemplateById($id: UUID!) @auth(level: USER) {
invoiceTemplate(id: $id) {
id
name
ownerId
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
createdAt
updatedAt
createdBy
vendor { id companyName }
business { id businessName email contactName }
order { id eventName status orderType }
}
}
# ----------------------------------------------------------
# LIST BY OWNER (my templates)
# ----------------------------------------------------------
query listInvoiceTemplatesByOwnerId(
$ownerId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoiceTemplates(
where: { ownerId: { eq: $ownerId } }
offset: $offset
limit: $limit
orderBy: { updatedAt: DESC }
) {
id
name
ownerId
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
createdAt
updatedAt
createdBy
vendor { id companyName }
business { id businessName email contactName }
order { id eventName status orderType }
}
}
# ----------------------------------------------------------
# LIST BY VENDOR (templates tied to a vendor)
# ----------------------------------------------------------
query listInvoiceTemplatesByVendorId(
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoiceTemplates(
where: { vendorId: { eq: $vendorId } }
offset: $offset
limit: $limit
orderBy: { updatedAt: DESC }
) {
id
name
ownerId
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
createdAt
updatedAt
createdBy
vendor { id companyName }
business { id businessName email contactName }
order { id eventName status orderType }
}
}
# ----------------------------------------------------------
# LIST BY BUSINESS (templates tied to a business)
# ----------------------------------------------------------
query listInvoiceTemplatesByBusinessId(
$businessId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoiceTemplates(
where: { businessId: { eq: $businessId } }
offset: $offset
limit: $limit
orderBy: { updatedAt: DESC }
) {
id
name
ownerId
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
createdAt
updatedAt
createdBy
vendor { id companyName }
business { id businessName email contactName }
order { id eventName status orderType }
}
}
# ----------------------------------------------------------
# LIST BY ORDER (templates tied to a specific order)
# ----------------------------------------------------------
query listInvoiceTemplatesByOrderId(
$orderId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoiceTemplates(
where: { orderId: { eq: $orderId } }
offset: $offset
limit: $limit
orderBy: { updatedAt: DESC }
) {
id
name
ownerId
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
createdAt
updatedAt
createdBy
vendor { id companyName }
business { id businessName email contactName }
order { id eventName status orderType }
}
}
# ----------------------------------------------------------
# SEARCH (by name) within an owner
# ----------------------------------------------------------
query searchInvoiceTemplatesByOwnerAndName(
$ownerId: UUID!
$name: String!
$offset: Int
$limit: Int
) @auth(level: USER) {
invoiceTemplates(
where: {
ownerId: { eq: $ownerId }
name: { eq: $name }
}
offset: $offset
limit: $limit
orderBy: { updatedAt: DESC }
) {
id
name
ownerId
vendorId
businessId
orderId
paymentTerms
invoiceNumber
issueDate
dueDate
hub
managerName
vendorNumber
roles
charges
otherCharges
subtotal
amount
notes
staffCount
chargesCount
createdAt
updatedAt
createdBy
vendor { id companyName }
business { id businessName email contactName }
order { id eventName status orderType }
}
}

37
apps/web/dataconnect/connector/level/mutations.gql Normal file
View File

@@ -0,0 +1,37 @@
mutation createLevel(
$name: String!
$xpRequired: Int!
$icon: String
$colors: Any
) @auth(level: USER) {
level_insert(
data: {
name: $name
xpRequired: $xpRequired
icon: $icon
colors: $colors
}
)
}
mutation updateLevel(
$id: UUID!
$name: String
$xpRequired: Int
$icon: String
$colors: Any
) @auth(level: USER) {
level_update(
id: $id
data: {
name: $name
xpRequired: $xpRequired
icon: $icon
colors: $colors
}
)
}
mutation deleteLevel($id: UUID!) @auth(level: USER) {
level_delete(id: $id)
}

44
apps/web/dataconnect/connector/level/queries.gql Normal file
View File

@@ -0,0 +1,44 @@
query listLevels @auth(level: USER) {
levels {
id
name
xpRequired
icon
colors
createdAt
updatedAt
createdBy
}
}
query getLevelById($id: UUID!) @auth(level: USER) {
level(id: $id) {
id
name
xpRequired
icon
colors
createdAt
updatedAt
createdBy
}
}
query filterLevels(
$name: String
$xpRequired: Int
) @auth(level: USER) {
levels(
where: {
name: { eq: $name }
xpRequired: { eq: $xpRequired }
}
) {
id
name
xpRequired
icon
colors
}
}

21
apps/web/dataconnect/connector/memberTask/mutations.gql Normal file
View File

@@ -0,0 +1,21 @@
mutation createMemberTask(
$teamMemberId: UUID!
$taskId: UUID!
) @auth(level: USER) {
memberTask_insert(
data: {
teamMemberId: $teamMemberId
taskId: $taskId
}
)
}
mutation deleteMemberTask(
$teamMemberId: UUID!
$taskId: UUID!
) @auth(level: USER) {
memberTask_delete(
key: { teamMemberId: $teamMemberId, taskId: $taskId }
)
}

77
apps/web/dataconnect/connector/memberTask/queries.gql Normal file
View File

@@ -0,0 +1,77 @@
query getMyTasks($teamMemberId: UUID!) @auth(level: USER) {
memberTasks(where: { teamMemberId: { eq: $teamMemberId } }) {
id
task {
id
taskName
description
status
dueDate
progress
priority
}
teamMember{
user {
fullName
email
}
}
}
}
#before named getMemberTaskByIdKey
query getMemberTaskByIdKey(
$teamMemberId: UUID!
$taskId: UUID!
) @auth(level: USER) {
memberTask(key: { teamMemberId: $teamMemberId, taskId: $taskId }) {
id
task {
id
taskName
description
status
dueDate
progress
priority
}
teamMember{
user {
fullName
email
}
}
}
}
query getMemberTasksByTaskId($taskId: UUID!) @auth(level: USER) {
memberTasks(where: { taskId: { eq: $taskId } }) {
id
task {
id
taskName
description
status
dueDate
progress
priority
}
teamMember{
user {
fullName
email
}
}
}
}

37
apps/web/dataconnect/connector/message/mutations.gql Normal file
View File

@@ -0,0 +1,37 @@
mutation createMessage(
$conversationId: UUID!,
$senderId: String!,
$content: String!,
$isSystem: Boolean
) @auth(level: USER) {
message_insert(
data: {
conversationId: $conversationId,
senderId: $senderId,
content: $content,
isSystem: $isSystem
}
)
}
mutation updateMessage(
$id: UUID!,
$conversationId: UUID,
$senderId: String,
$content: String,
$isSystem: Boolean
) @auth(level: USER) {
message_update(
id: $id,
data: {
conversationId: $conversationId,
senderId: $senderId,
content: $content,
isSystem: $isSystem
}
)
}
mutation deleteMessage($id: UUID!) @auth(level: USER) {
message_delete(id: $id)
}

41
apps/web/dataconnect/connector/message/queries.gql Normal file
View File

@@ -0,0 +1,41 @@
query listMessages @auth(level: USER) {
messages {
id
conversationId
senderId
content
isSystem
createdAt
user{
fullName
}
}
}
query getMessageById($id: UUID!) @auth(level: USER) {
message(id: $id) {
id
conversationId
senderId
content
isSystem
createdAt
user{
fullName
}
}
}
query getMessagesByConversationId($conversationId: UUID!) @auth(level: USER) {
messages(where: { conversationId: { eq: $conversationId } }) {
id
conversationId
senderId
content
isSystem
createdAt
user{
fullName
}
}
}

100
apps/web/dataconnect/connector/order/mutations.gql Normal file
View File

@@ -0,0 +1,100 @@
mutation createOrder(
$vendorId: UUID
$businessId: UUID!
$orderType: OrderType!
$location: String
$status: OrderStatus
$date: Timestamp
$startDate: Timestamp
$endDate: Timestamp
$duration: OrderDuration
$lunchBreak: Int
$total: Float
$eventName: String
$assignedStaff: Any
$shifts: Any
$requested: Int
$hub: String
$recurringDays: Any
$permanentStartDate: Timestamp
$permanentDays: Any
$notes: String
$detectedConflicts: Any
$poReference: String
) @auth(level: USER) {
order_insert(
data: {
vendorId: $vendorId
businessId: $businessId
orderType: $orderType
location: $location
status: $status
date: $date
startDate: $startDate
endDate: $endDate
duration: $duration
lunchBreak: $lunchBreak
total: $total
eventName: $eventName
assignedStaff: $assignedStaff
shifts: $shifts
requested: $requested
hub: $hub
recurringDays: $recurringDays
permanentDays: $permanentDays
notes: $notes
detectedConflicts: $detectedConflicts
poReference: $poReference
}
)
}
mutation updateOrder(
$id: UUID!
$vendorId: UUID
$businessId: UUID
$location: String
$status: OrderStatus
$date: Timestamp
$startDate: Timestamp
$endDate: Timestamp
$total: Float
$eventName: String
$assignedStaff: Any
$shifts: Any
$requested: Int
$hub: String
$recurringDays: Any
$permanentDays: Any
$notes: String
$detectedConflicts: Any
$poReference: String
) @auth(level: USER) {
order_update(
id: $id
data: {
vendorId: $vendorId
businessId: $businessId
location: $location
status: $status
date: $date
startDate: $startDate
endDate: $endDate
total: $total
eventName: $eventName
assignedStaff: $assignedStaff
shifts: $shifts
requested: $requested
hub: $hub
recurringDays: $recurringDays
permanentDays: $permanentDays
notes: $notes
detectedConflicts: $detectedConflicts
poReference: $poReference
}
)
}
mutation deleteOrder($id: UUID!) @auth(level: USER) {
order_delete(id: $id)
}

352
apps/web/dataconnect/connector/order/queries.gql Normal file
View File

@@ -0,0 +1,352 @@
# ------------------------------------------------------------
# LIST ALL ORDERS
# ------------------------------------------------------------
query listOrders(
$offset: Int
$limit: Int
) @auth(level: USER) {
orders(offset: $offset, limit: $limit) {
id
eventName
vendorId
businessId
orderType
location
status
date
startDate
endDate
duration
lunchBreak
total
assignedStaff
shifts
requested
hub
recurringDays
permanentDays
poReference
detectedConflicts
notes
createdAt
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
# ------------------------------------------------------------
# GET ORDER BY ID
# ------------------------------------------------------------
query getOrderById($id: UUID!) @auth(level: USER) {
order(id: $id) {
id
eventName
vendorId
businessId
orderType
location
status
date
startDate
endDate
duration
lunchBreak
total
assignedStaff
shifts
requested
hub
recurringDays
permanentDays
poReference
detectedConflicts
notes
createdAt
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
# ------------------------------------------------------------
# GET ORDERS BY BUSINESS
# ------------------------------------------------------------
query getOrdersByBusinessId(
$businessId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
orders(
where: { businessId: { eq: $businessId } }
offset: $offset
limit: $limit
) {
id
eventName
vendorId
businessId
orderType
location
status
date
startDate
endDate
duration
lunchBreak
total
assignedStaff
shifts
requested
hub
recurringDays
permanentDays
poReference
detectedConflicts
notes
createdAt
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
# ------------------------------------------------------------
# GET ORDERS BY VENDOR
# ------------------------------------------------------------
query getOrdersByVendorId(
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
orders(
where: { vendorId: { eq: $vendorId } }
offset: $offset
limit: $limit
) {
id
eventName
vendorId
businessId
orderType
location
status
date
startDate
endDate
duration
lunchBreak
total
assignedStaff
shifts
requested
hub
recurringDays
permanentDays
poReference
detectedConflicts
notes
createdAt
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
# ------------------------------------------------------------
# GET ORDERS BY STATUS
# ------------------------------------------------------------
query getOrdersByStatus(
$status: OrderStatus!
$offset: Int
$limit: Int
) @auth(level: USER) {
orders(
where: { status: { eq: $status } }
offset: $offset
limit: $limit
) {
id
eventName
vendorId
businessId
orderType
location
status
date
startDate
endDate
duration
lunchBreak
total
assignedStaff
shifts
requested
hub
recurringDays
permanentDays
poReference
detectedConflicts
notes
createdAt
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
# ------------------------------------------------------------
# GET ORDERS BY DATE RANGE
# ------------------------------------------------------------
query getOrdersByDateRange(
$start: Timestamp!
$end: Timestamp!
$offset: Int
$limit: Int
) @auth(level: USER) {
orders(
where: {
date: { ge: $start, le: $end }
}
offset: $offset
limit: $limit
) {
id
eventName
vendorId
businessId
orderType
location
status
date
startDate
endDate
duration
lunchBreak
total
assignedStaff
shifts
requested
hub
recurringDays
permanentDays
poReference
detectedConflicts
notes
createdAt
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}
# ------------------------------------------------------------
# GET RAPID ORDERS
# ------------------------------------------------------------
query getRapidOrders(
$offset: Int
$limit: Int
) @auth(level: USER) {
orders(
where: { orderType: { eq: RAPID } }
offset: $offset
limit: $limit
) {
id
eventName
vendorId
businessId
orderType
location
status
date
startDate
endDate
duration
lunchBreak
total
assignedStaff
shifts
requested
hub
recurringDays
permanentDays
poReference
detectedConflicts
notes
createdAt
business {
id
businessName
email
contactName
}
vendor {
id
companyName
}
}
}

41
apps/web/dataconnect/connector/recentPayment/mutations.gql Normal file
View File

@@ -0,0 +1,41 @@
mutation createRecentPayment(
$workedTime: String
$status: RecentPaymentStatus
$staffId: UUID!
$applicationId: UUID!
$invoiceId: UUID!
) @auth(level: USER) {
recentPayment_insert(
data: {
workedTime: $workedTime
status: $status
staffId: $staffId
applicationId: $applicationId
invoiceId: $invoiceId
}
)
}
mutation updateRecentPayment(
$id: UUID!
$workedTime: String
$status: RecentPaymentStatus
$staffId: UUID
$applicationId: UUID
$invoiceId: UUID
) @auth(level: USER) {
recentPayment_update(
id: $id
data: {
workedTime: $workedTime
status: $status
staffId: $staffId
applicationId: $applicationId
invoiceId: $invoiceId
}
)
}
mutation deleteRecentPayment($id: UUID!) @auth(level: USER) {
recentPayment_delete(id: $id)
}

417
apps/web/dataconnect/connector/recentPayment/queries.gql Normal file
View File

@@ -0,0 +1,417 @@
# ------------------------------------------------------------
# LIST ALL (admin/debug)
# ------------------------------------------------------------
query listRecentPayments(
$offset: Int
$limit: Int
) @auth(level: USER) {
recentPayments(offset: $offset, limit: $limit) {
id
workedTime
status
staffId
applicationId
invoiceId
createdAt
updatedAt
createdBy
application {
checkInTime
checkOutTime
shiftRole {
hours
totalValue
startTime
endTime
role {
name
costPerHour
}
shift {
title
date
location
locationAddress
description
}
}
}
invoice {
status
invoiceNumber
issueDate
business { id businessName }
vendor { id companyName }
order { id eventName }
}
}
}
# ------------------------------------------------------------
# GET BY ID
# ------------------------------------------------------------
query getRecentPaymentById($id: UUID!) @auth(level: USER) {
recentPayment(id: $id) {
id
workedTime
status
staffId
applicationId
invoiceId
createdAt
updatedAt
createdBy
application {
checkInTime
checkOutTime
shiftRole {
hours
totalValue
startTime
endTime
role {
name
costPerHour
}
shift {
title
date
location
locationAddress
description
}
}
}
invoice {
status
invoiceNumber
issueDate
business { id businessName }
vendor { id companyName }
order { id eventName }
}
}
}
# ------------------------------------------------------------
# LIST BY STAFF (Staff view)
# ------------------------------------------------------------
query listRecentPaymentsByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
recentPayments(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
id
workedTime
status
staffId
applicationId
invoiceId
createdAt
updatedAt
createdBy
application {
id
status
shiftRole {
startTime
endTime
hours
totalValue
role { id name costPerHour }
shift {
id
title
date
locationAddress
}
}
}
invoice {
id
invoiceNumber
status
issueDate
dueDate
amount
business { id businessName }
vendor { id companyName }
order { id eventName location }
}
}
}
# ------------------------------------------------------------
# LIST BY APPLICATION (debug / trace)
# ------------------------------------------------------------
query listRecentPaymentsByApplicationId(
$applicationId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
recentPayments(
where: { applicationId: { eq: $applicationId } }
offset: $offset
limit: $limit
) {
id
workedTime
status
staffId
applicationId
invoiceId
createdAt
updatedAt
createdBy
application {
id
status
shiftRole {
hours
totalValue
role { id name costPerHour }
shift { id title date locationAddress }
}
}
invoice {
id
invoiceNumber
status
amount
business { id businessName }
vendor { id companyName }
order { id eventName location }
}
}
}
# ------------------------------------------------------------
# LIST BY INVOICE (Vendor/Business can see all payments for invoice)
# ------------------------------------------------------------
query listRecentPaymentsByInvoiceId(
$invoiceId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
recentPayments(
where: { invoiceId: { eq: $invoiceId } }
offset: $offset
limit: $limit
) {
id
workedTime
status
staffId
applicationId
invoiceId
createdAt
updatedAt
createdBy
application {
id
staffId
shiftRole {
hours
totalValue
role { id name costPerHour }
shift { id title date locationAddress }
}
}
invoice {
id
invoiceNumber
status
amount
business { id businessName }
vendor { id companyName }
order { id eventName location }
}
}
}
# ------------------------------------------------------------
# FILTER BY STATUS (common)
# ------------------------------------------------------------
query listRecentPaymentsByStatus(
$status: RecentPaymentStatus!
$offset: Int
$limit: Int
) @auth(level: USER) {
recentPayments(
where: { status: { eq: $status } }
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
id
workedTime
status
staffId
applicationId
invoiceId
createdAt
updatedAt
createdBy
application {
id
shiftRole {
hours
totalValue
role { id name costPerHour }
shift { id title date locationAddress }
}
}
invoice {
id
invoiceNumber
status
amount
business { id businessName }
vendor { id companyName }
order { id eventName location }
}
}
}
# ------------------------------------------------------------
# BY BUSINESS (2-step)
# Step 2: pass invoiceIds (from query: listInvoicesByBusinessId)
# ------------------------------------------------------------
query listRecentPaymentsByInvoiceIds(
$invoiceIds: [UUID!]!
$offset: Int
$limit: Int
) @auth(level: USER) {
recentPayments(
where: { invoiceId: { in: $invoiceIds } }
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
id
workedTime
status
staffId
applicationId
invoiceId
createdAt
updatedAt
createdBy
application {
id
shiftRole {
hours
totalValue
role { id name costPerHour }
shift { id title date locationAddress }
}
}
invoice {
id
invoiceNumber
status
amount
business { id businessName }
vendor { id companyName }
order { id eventName location }
}
}
}
# ------------------------------------------------------------
# LIST BY BUSINESS ID (direct)
# ------------------------------------------------------------
query listRecentPaymentsByBusinessId(
$businessId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
recentPayments(
where: {
invoice: {
businessId: { eq: $businessId }
}
}
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
id
workedTime
status
staffId
applicationId
invoiceId
createdAt
updatedAt
createdBy
application {
id
staffId
checkInTime
checkOutTime
shiftRole {
startTime
endTime
hours
totalValue
role { id name costPerHour }
shift {
id
title
date
location
locationAddress
description
}
}
}
invoice {
id
invoiceNumber
status
issueDate
dueDate
amount
business { id businessName }
vendor { id companyName }
order { id eventName location }
}
}
}

455
apps/web/dataconnect/connector/reports/queries.gql Normal file
View File

@@ -0,0 +1,455 @@
# ==========================================================
# Reports Connector - For MVP
# ==========================================================
# This file exposes SOURCE-DATA queries for all report screens.
# All aggregation (group by day/week, percentages, averages)
# is intentionally done on the client (Flutter).
#
# Entities used:
# - Shift
# - Application
# - Staff
# - Invoice
# - TimeSheet
#
# NOTE:
# Data Connect does NOT support custom root resolvers.
# These queries return raw rows from @table entities.
# ==========================================================
# ==========================================================
# 1) COVERAGE REPORT (Next 7 days)
# ==========================================================
# Coverage definition:
# - Needed: sum(Shift.workersNeeded) grouped by date
# - Confirmed: count(Application) where status IN (...)
#
# Client groups by Shift.date and calculates:
# coveragePercentage = confirmed / needed * 100
# ==========================================================
query listShiftsForCoverage(
$businessId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { businessId: { eq: $businessId } }
date: { ge: $startDate, le: $endDate }
}
orderBy: { date: ASC }
) {
id
date
workersNeeded
filled
status
}
}
#I comment here because I have an error en sdk
query listApplicationsForCoverage(
$shiftIds: [UUID!]!
#$statuses: [ApplicationStatus!]!
) @auth(level: USER) {
applications(
where: {
shiftId: { in: $shiftIds }
#status: { in: $statuses }
}
) {
id
shiftId
staffId
status
}
}
# ==========================================================
# 2) DAILY OPS REPORT (Single day)
# ==========================================================
# Metrics derived on client:
# - scheduledShifts = shifts.length
# - workersConfirmed = confirmedApps / totalNeeded
# - inProgressShifts = status == IN_PROGRESS
# - completedShifts = status == COMPLETED
# ==========================================================
query listShiftsForDailyOpsByBusiness(
$businessId: UUID!
$date: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { businessId: { eq: $businessId } }
date: { eq: $date }
}
orderBy: { startTime: ASC }
) {
id
title
location
startTime
endTime
workersNeeded
filled
status
}
}
query listShiftsForDailyOpsByVendor(
$vendorId: UUID!
$date: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { vendorId: { eq: $vendorId } }
date: { eq: $date }
}
orderBy: { startTime: ASC }
) {
id
title
location
startTime
endTime
workersNeeded
filled
status
}
}
query listApplicationsForDailyOps(
$shiftIds: [UUID!]!
) @auth(level: USER) {
applications(where: { shiftId: { in: $shiftIds } }) {
id
shiftId
staffId
status
checkInTime
checkOutTime
}
}
# ==========================================================
# 3) FORECAST REPORT (Next N weeks)
# ==========================================================
# Projected spend formula (client):
# projectedCost = workersNeeded * hours * hourlyRate
# ==========================================================
query listShiftsForForecastByBusiness(
$businessId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { businessId: { eq: $businessId } }
date: { ge: $startDate, le: $endDate }
}
orderBy: { date: ASC }
) {
id
date
workersNeeded
hours
cost
status
}
}
query listShiftsForForecastByVendor(
$vendorId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { vendorId: { eq: $vendorId } }
date: { ge: $startDate, le: $endDate }
}
orderBy: { date: ASC }
) {
id
date
workersNeeded
hours
cost
status
}
}
# ==========================================================
# 4) NO-SHOW REPORT (Historical range)
# ==========================================================
# Now fully supported because ApplicationStatus includes NO_SHOW.
#
# Metrics:
# - totalNoShows = count(status == NO_SHOW)
# - noShowRate = noShows / totalApplications
# - breakdown by staff
# ==========================================================
query listShiftsForNoShowRangeByBusiness(
$businessId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { businessId: { eq: $businessId } }
date: { ge: $startDate, le: $endDate }
}
) {
id
date
}
}
query listShiftsForNoShowRangeByVendor(
$vendorId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { vendorId: { eq: $vendorId } }
date: { ge: $startDate, le: $endDate }
}
) {
id
date
}
}
query listApplicationsForNoShowRange(
$shiftIds: [UUID!]!
) @auth(level: USER) {
applications(where: { shiftId: { in: $shiftIds } }) {
id
shiftId
staffId
status
}
}
query listStaffForNoShowReport(
$staffIds: [UUID!]!
) @auth(level: USER) {
staffs(where: { id: { in: $staffIds } }) {
id
fullName
noShowCount
reliabilityScore
}
}
# ==========================================================
# 5) SPEND REPORT (Financial)
# ==========================================================
# Uses Invoice as source of truth for money.
# Filter is now based on:
# - businessId (business dashboard)
# - vendorId (vendor dashboard)
# since Invoice no longer has ownerId.
# ==========================================================
query listInvoicesForSpendByBusiness(
$businessId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
invoices(
where: {
businessId: { eq: $businessId }
issueDate: { ge: $startDate, le: $endDate }
}
orderBy: { issueDate: ASC }
) {
id
issueDate
dueDate
amount
status
invoiceNumber
vendor { id companyName }
business { id businessName }
order { id eventName }
}
}
query listInvoicesForSpendByVendor(
$vendorId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
invoices(
where: {
vendorId: { eq: $vendorId }
issueDate: { ge: $startDate, le: $endDate }
}
orderBy: { issueDate: ASC }
) {
id
issueDate
dueDate
amount
status
invoiceNumber
vendor { id companyName }
business { id businessName }
order { id eventName }
}
}
# Optional: Spend by Order (if you need it)
query listInvoicesForSpendByOrder(
$orderId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
invoices(
where: {
orderId: { eq: $orderId }
issueDate: { ge: $startDate, le: $endDate }
}
orderBy: { issueDate: ASC }
) {
id
issueDate
dueDate
amount
status
invoiceNumber
vendor { id companyName }
business { id businessName }
order { id eventName }
}
}
query listTimesheetsForSpend(
$startTime: Timestamp!
$endTime: Timestamp!
) @auth(level: USER) {
shiftRoles(
where: {
shift: {
date: { ge: $startTime, le: $endTime }
}
}
) {
id
hours
totalValue
shift{
title
location
status
date
order{
business{
businessName
}
}
}
role{
costPerHour
}
}
}
# ==========================================================
# 6) PERFORMANCE REPORT (Historical KPIs)
# ==========================================================
# Metrics derivable:
# - fillRate
# - completionRate
# - onTimeRate
# - avgFillTimeHours (NOW POSSIBLE 🎉)
#
# avgFillTimeHours formula:
# (filledAt - createdAt) averaged across FILLED shifts
# ==========================================================
query listShiftsForPerformanceByBusiness(
$businessId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { businessId: { eq: $businessId } }
date: { ge: $startDate, le: $endDate }
filledAt: { isNull: false }
}
) {
id
workersNeeded
filled
status
createdAt
filledAt
}
}
query listShiftsForPerformanceByVendor(
$vendorId: UUID!
$startDate: Timestamp!
$endDate: Timestamp!
) @auth(level: USER) {
shifts(
where: {
order: { vendorId: { eq: $vendorId } }
date: { ge: $startDate, le: $endDate }
filledAt: { isNull: false }
}
) {
id
workersNeeded
filled
status
createdAt
filledAt
}
}
query listApplicationsForPerformance(
$shiftIds: [UUID!]!
) @auth(level: USER) {
applications(where: { shiftId: { in: $shiftIds } }) {
id
shiftId
staffId
status
checkInTime
checkOutTime
}
}
query listStaffForPerformance(
$staffIds: [UUID!]!
) @auth(level: USER) {
staffs(where: { id: { in: $staffIds } }) {
id
averageRating
onTimeRate
noShowCount
reliabilityScore
}
}

36
apps/web/dataconnect/connector/role/mutations.gql Normal file
View File

@@ -0,0 +1,36 @@
mutation createRole(
$name: String!
$costPerHour: Float!
$vendorId: UUID!
$roleCategoryId: UUID!
) @auth(level: USER) {
role_insert(
data: {
name: $name
costPerHour: $costPerHour
vendorId: $vendorId
roleCategoryId: $roleCategoryId
}
)
}
mutation updateRole(
$id: UUID!
$name: String
$costPerHour: Float
$roleCategoryId: UUID!
) @auth(level: USER) {
role_update(
id: $id
data: {
name: $name
costPerHour: $costPerHour
roleCategoryId: $roleCategoryId
}
)
}
mutation deleteRole($id: UUID!) @auth(level: USER) {
role_delete(id: $id)
}

43
apps/web/dataconnect/connector/role/queries.gql Normal file
View File

@@ -0,0 +1,43 @@
query listRoles @auth(level: USER) {
roles {
id
name
costPerHour
vendorId
roleCategoryId
createdAt
}
}
query getRoleById($id: UUID!) @auth(level: USER) {
role(id: $id) {
id
name
costPerHour
vendorId
roleCategoryId
createdAt
}
}
query listRolesByVendorId($vendorId: UUID!) @auth(level: USER) {
roles(where: { vendorId: { eq: $vendorId } }) {
id
name
costPerHour
vendorId
roleCategoryId
createdAt
}
}
query listRolesByroleCategoryId($roleCategoryId: UUID!) @auth(level: USER) {
roles(where: { roleCategoryId: { eq: $roleCategoryId } }) {
id
name
costPerHour
vendorId
roleCategoryId
createdAt
}
}

29
apps/web/dataconnect/connector/roleCategory/mutations.gql Normal file
View File

@@ -0,0 +1,29 @@
mutation createRoleCategory(
$roleName: String!,
$category: RoleCategoryType!
) @auth(level: USER) {
roleCategory_insert(
data: {
roleName: $roleName,
category: $category
}
)
}
mutation updateRoleCategory(
$id: UUID!,
$roleName: String,
$category: RoleCategoryType
) @auth(level: USER) {
roleCategory_update(
id: $id,
data: {
roleName: $roleName,
category: $category
}
)
}
mutation deleteRoleCategory($id: UUID!) @auth(level: USER) {
roleCategory_delete(id: $id)
}

27
apps/web/dataconnect/connector/roleCategory/queries.gql Normal file
View File

@@ -0,0 +1,27 @@
query listRoleCategories @auth(level: USER) {
roleCategories {
id
roleName
category
createdAt
updatedAt
}
}
query getRoleCategoryById($id: UUID!) @auth(level: USER) {
roleCategory(id: $id) {
id
roleName
category
createdAt
updatedAt
}
}
query getRoleCategoriesByCategory($category: RoleCategoryType!) @auth(level: USER) {
roleCategories(where: { category: { eq: $category } }) {
id
roleName
category
}
}

114
apps/web/dataconnect/connector/shift/mutations.gql Normal file
View File

@@ -0,0 +1,114 @@
mutation createShift(
$title: String!
$orderId: UUID!
$date: Timestamp
$startTime: Timestamp
$endTime: Timestamp
$hours: Float
$cost: Float
$location: String
$locationAddress: String
$latitude: Float
$longitude: Float
$description: String
$status: ShiftStatus
$workersNeeded: Int
$filled: Int
$filledAt: Timestamp
$managers: [Any!]
$durationDays: Int
$createdBy: String
) @auth(level: USER) {
shift_insert(
data: {
title: $title
orderId: $orderId
date: $date
startTime: $startTime
endTime: $endTime
hours: $hours
cost: $cost
location: $location
locationAddress: $locationAddress
latitude: $latitude
longitude: $longitude
description: $description
status: $status
workersNeeded: $workersNeeded
filled: $filled
filledAt: $filledAt
managers: $managers
durationDays: $durationDays
}
)
}
mutation updateShift(
$id: UUID!
$title: String
$orderId: UUID
$date: Timestamp
$startTime: Timestamp
$endTime: Timestamp
$hours: Float
$cost: Float
$location: String
$locationAddress: String
$latitude: Float
$longitude: Float
$description: String
$status: ShiftStatus
$workersNeeded: Int
$filled: Int
$filledAt: Timestamp
$managers: [Any!]
$durationDays: Int
) @auth(level: USER) {
shift_update(
id: $id
data: {
title: $title
orderId: $orderId
date: $date
startTime: $startTime
endTime: $endTime
hours: $hours
cost: $cost
location: $location
locationAddress: $locationAddress
latitude: $latitude
longitude: $longitude
description: $description
status: $status
workersNeeded: $workersNeeded
filled: $filled
filledAt: $filledAt
managers: $managers
durationDays: $durationDays
}
)
}
mutation deleteShift($id: UUID!) @auth(level: USER) {
shift_delete(id: $id)
}

282
apps/web/dataconnect/connector/shift/queries.gql Normal file
View File

@@ -0,0 +1,282 @@
# ------------------------------------------------------------
# LIST SHIFTS (paginated)
# ------------------------------------------------------------
query listShifts(
$offset: Int
$limit: Int
) @auth(level: USER) {
shifts(offset: $offset, limit: $limit) {
id
title
orderId
date
startTime
endTime
hours
cost
location
locationAddress
latitude
longitude
description
status
workersNeeded
filled
filledAt
managers
durationDays
createdAt
updatedAt
createdBy
order {
id
eventName
status
orderType
businessId
vendorId
business { id businessName email contactName }
vendor { id companyName }
}
}
}
# ------------------------------------------------------------
# GET SHIFT BY ID
# ------------------------------------------------------------
query getShiftById($id: UUID!) @auth(level: USER) {
shift(id: $id) {
id
title
orderId
date
startTime
endTime
hours
cost
location
locationAddress
latitude
longitude
description
status
workersNeeded
filled
filledAt
managers
durationDays
createdAt
updatedAt
createdBy
order {
id
eventName
status
orderType
businessId
vendorId
business { id businessName email contactName }
vendor { id companyName }
}
}
}
# ------------------------------------------------------------
# FILTER SHIFTS (by status/orderId/date range)
# NOTE: Timestamp filters use ge/le (not gte/lte)
# ------------------------------------------------------------
query filterShifts(
$status: ShiftStatus
$orderId: UUID
$dateFrom: Timestamp
$dateTo: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
shifts(
where: {
status: { eq: $status }
orderId: { eq: $orderId }
date: { ge: $dateFrom, le: $dateTo }
}
offset: $offset
limit: $limit
) {
id
title
orderId
date
startTime
endTime
hours
cost
location
locationAddress
latitude
longitude
description
status
workersNeeded
filled
filledAt
managers
durationDays
createdAt
updatedAt
createdBy
order {
id
eventName
status
orderType
businessId
vendorId
business { id businessName email contactName }
vendor { id companyName }
}
}
}
# ------------------------------------------------------------
# BUSINESS: GET SHIFTS FOR A BUSINESS (via order.businessId)
# ------------------------------------------------------------
query getShiftsByBusinessId(
$businessId: UUID!
$dateFrom: Timestamp
$dateTo: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
shifts(
where: {
order: { businessId: { eq: $businessId } }
date: { ge: $dateFrom, le: $dateTo }
}
offset: $offset
limit: $limit
) {
id
title
orderId
date
startTime
endTime
hours
cost
location
locationAddress
latitude
longitude
description
status
workersNeeded
filled
filledAt
managers
durationDays
createdAt
updatedAt
createdBy
order {
id
eventName
status
orderType
businessId
vendorId
business { id businessName email contactName }
vendor { id companyName }
}
}
}
# ------------------------------------------------------------
# VENDOR: GET SHIFTS FOR A VENDOR (via order.vendorId)
# ------------------------------------------------------------
query getShiftsByVendorId(
$vendorId: UUID!
$dateFrom: Timestamp
$dateTo: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
shifts(
where: {
order: { vendorId: { eq: $vendorId } }
date: { ge: $dateFrom, le: $dateTo }
}
offset: $offset
limit: $limit
) {
id
title
orderId
date
startTime
endTime
hours
cost
location
locationAddress
latitude
longitude
description
status
workersNeeded
filled
filledAt
managers
durationDays
createdAt
updatedAt
createdBy
order {
id
eventName
status
orderType
businessId
vendorId
business { id businessName email contactName }
vendor { id companyName }
}
}
}

65
apps/web/dataconnect/connector/shiftRole/mutations.gql Normal file
View File

@@ -0,0 +1,65 @@
mutation createShiftRole(
$shiftId: UUID!
$roleId: UUID!
$count: Int!
$assigned: Int
$startTime: Timestamp
$endTime: Timestamp
$hours: Float
$department: String
$uniform: String
$breakType: BreakDuration
$totalValue: Float
) @auth(level: USER) {
shiftRole_insert(
data: {
shiftId: $shiftId
roleId: $roleId
count: $count
assigned: $assigned
startTime: $startTime
endTime: $endTime
hours: $hours
department: $department
uniform: $uniform
breakType: $breakType
totalValue: $totalValue
}
)
}
mutation updateShiftRole(
$shiftId: UUID!
$roleId: UUID!
$count: Int
$assigned: Int
$startTime: Timestamp
$endTime: Timestamp
$hours: Float
$department: String
$uniform: String
$breakType: BreakDuration
$totalValue: Float
) @auth(level: USER) {
shiftRole_update(
key: { shiftId: $shiftId, roleId: $roleId }
data: {
count: $count
assigned: $assigned
startTime: $startTime
endTime: $endTime
hours: $hours
department: $department
uniform: $uniform
breakType: $breakType
totalValue: $totalValue
}
)
}
mutation deleteShiftRole(
$shiftId: UUID!
$roleId: UUID!
) @auth(level: USER) {
shiftRole_delete(key: { shiftId: $shiftId, roleId: $roleId })
}

526
apps/web/dataconnect/connector/shiftRole/queries.gql Normal file
View File

@@ -0,0 +1,526 @@
query getShiftRoleById(
$shiftId: UUID!
$roleId: UUID!
) @auth(level: USER) {
shiftRole(key: { shiftId: $shiftId, roleId: $roleId }) {
id
shiftId
roleId
count
assigned
startTime
endTime
hours
department
uniform
breakType
totalValue
createdAt
role {
id
name
costPerHour
}
shift{
location
locationAddress
description
orderId
order{
recurringDays
permanentDays
notes
business{
id
businessName
}
vendor{
id
companyName
}
}
}
}
}
query listShiftRolesByShiftId(
$shiftId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
shiftRoles(
where: { shiftId: { eq: $shiftId } }
offset: $offset
limit: $limit
) {
id
shiftId
roleId
count
assigned
startTime
endTime
hours
department
uniform
breakType
totalValue
createdAt
role {
id
name
costPerHour
}
shift{
location
locationAddress
description
orderId
order{
recurringDays
permanentDays
notes
business{
id
businessName
}
vendor{
id
companyName
}
}
}
}
}
query listShiftRolesByRoleId(
$roleId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
shiftRoles(
where: { roleId: { eq: $roleId } }
offset: $offset
limit: $limit
) {
id
shiftId
roleId
count
assigned
startTime
endTime
hours
department
uniform
breakType
totalValue
createdAt
role {
id
name
costPerHour
}
shift{
location
locationAddress
description
orderId
order{
recurringDays
permanentDays
notes
business{
id
businessName
}
vendor{
id
companyName
}
}
}
}
}
query listShiftRolesByShiftIdAndTimeRange(
$shiftId: UUID!
$start: Timestamp!
$end: Timestamp!
$offset: Int
$limit: Int
) @auth(level: USER) {
shiftRoles(
where: {
shiftId: { eq: $shiftId }
startTime: { ge: $start }
endTime: { le: $end }
}
offset: $offset
limit: $limit
) {
id
shiftId
roleId
count
assigned
startTime
endTime
hours
department
uniform
breakType
totalValue
createdAt
role {
id
name
costPerHour
}
shift{
location
locationAddress
description
orderId
order{
recurringDays
permanentDays
notes
business{
id
businessName
}
vendor{
id
companyName
}
}
}
}
}
# ------------------------------------------------------------
# LIST SHIFT ROLES BY VENDOR (via Shift -> Order)
# ------------------------------------------------------------
query listShiftRolesByVendorId(
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
shiftRoles(
where: {
shift: {
order: {
vendorId: { eq: $vendorId }
}
}
}
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
id
shiftId
roleId
count
assigned
startTime
endTime
hours
department
uniform
breakType
totalValue
createdAt
role {
id
name
costPerHour
}
shift {
id
title
date
location
locationAddress
description
orderId
order {
id
eventName
vendorId
businessId
orderType
status
date
recurringDays
permanentDays
notes
business { id businessName }
vendor { id companyName }
}
}
}
}
#orders view client
query listShiftRolesByBusinessAndDateRange(
$businessId: UUID!
$start: Timestamp!
$end: Timestamp!
$offset: Int
$limit: Int
$status: ShiftStatus
) @auth(level: USER) {
shiftRoles(
where: {
shift: {
date: { ge: $start, le: $end }
order: { businessId: { eq: $businessId } }
status: { eq: $status }
}
}
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
shiftId
roleId
count
assigned
hours
startTime
endTime
totalValue
role { id name }
shift {
id
date
location
locationAddress
title
status
order { id }
}
}
}
#list shiftsroles for update order in client app
query listShiftRolesByBusinessAndOrder(
$businessId: UUID!
$orderId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
shiftRoles(
where: {
shift: {
orderId: { eq: $orderId }
order: { businessId: { eq: $businessId } }
}
}
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
id
shiftId
roleId
count
assigned
startTime
endTime
hours
breakType
totalValue
createdAt
role { id name costPerHour }
shift {
id
title
date
orderId
location
locationAddress
order{
vendorId
date
location
}
}
}
}
#reorder get list by businessId
query listShiftRolesByBusinessDateRangeCompletedOrders(
$businessId: UUID!
$start: Timestamp!
$end: Timestamp!
$offset: Int
$limit: Int
) @auth(level: USER) {
shiftRoles(
where: {
shift: {
date: { ge: $start, le: $end }
order: {
businessId: { eq: $businessId }
status: { eq: COMPLETED }
}
}
}
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
shiftId
roleId
count
assigned
hours
startTime
endTime
totalValue
role {
id
name
costPerHour
}
shift {
id
date
location
locationAddress
title
status
order {
id
orderType
}
}
}
}
#view for billing period
query listShiftRolesByBusinessAndDatesSummary(
$businessId: UUID!
$start: Timestamp!
$end: Timestamp!
$offset: Int
$limit: Int
) @auth(level: USER) {
shiftRoles(
where: {
shift: {
date: { ge: $start, le: $end }
status: { eq: COMPLETED }
order: { businessId: { eq: $businessId } }
}
}
offset: $offset
limit: $limit
orderBy: { createdAt: DESC }
) {
roleId
hours
totalValue
role { id name }
}
}
# ------------------------------------------------------------
# BUSINESS: GET COMPLETED SHIFTS FOR A BUSINESS (via order.businessId)
# ------------------------------------------------------------
#for spending insights in home view
query getCompletedShiftsByBusinessId(
$businessId: UUID!
$dateFrom: Timestamp!
$dateTo: Timestamp!
$offset: Int
$limit: Int
) @auth(level: USER) {
shifts(
where: {
order: { businessId: { eq: $businessId } }
status: {in: [IN_PROGRESS, CONFIRMED, COMPLETED, OPEN]}
date: { ge: $dateFrom, le: $dateTo }
}
offset: $offset
limit: $limit
) {
id
#title
#orderId
date
startTime
endTime
hours
cost
#location
#locationAddress
#latitude
#longitude
#description
#status
workersNeeded
filled
#filledAt
#managers
#durationDays
createdAt
order {
#id
#eventName
status
#orderType
#businessId
#vendorId
#business { id businessName email contactName }
#vendor { id companyName }
}
}
}

184
apps/web/dataconnect/connector/staff/mutations.gql Normal file
View File

@@ -0,0 +1,184 @@
mutation CreateStaff(
$userId: String!
$fullName: String!
$level: String
$role: String
$phone: String
$email: String
$photoUrl: String
$totalShifts: Int
$averageRating: Float
$onTimeRate: Int
$noShowCount: Int
$cancellationCount: Int
$reliabilityScore: Int
$bio: String
$skills: [String!]
$industries: [String!]
$preferredLocations: [String!]
$maxDistanceMiles: Int
$languages: Any
$itemsAttire: Any
$xp: Int
$badges: Any
$isRecommended: Boolean
$ownerId: UUID
$department: DepartmentType
$hubId: UUID
$manager: UUID
$english: EnglishProficiency
$backgroundCheckStatus: BackgroundCheckStatus
$employmentType: EmploymentType
$initial: String
$englishRequired: Boolean
$city: String
$addres: String
) @auth(level: USER) {
staff_insert(
data: {
userId: $userId
fullName: $fullName
level: $level
role: $role
phone: $phone
email: $email
photoUrl: $photoUrl
totalShifts: $totalShifts
averageRating: $averageRating
onTimeRate: $onTimeRate
noShowCount: $noShowCount
cancellationCount: $cancellationCount
reliabilityScore: $reliabilityScore
bio: $bio
skills: $skills
industries: $industries
preferredLocations: $preferredLocations
maxDistanceMiles: $maxDistanceMiles
languages: $languages
itemsAttire: $itemsAttire
xp: $xp
badges: $badges
isRecommended: $isRecommended
ownerId: $ownerId
department: $department
hubId: $hubId
manager: $manager
english: $english
backgroundCheckStatus: $backgroundCheckStatus
employmentType: $employmentType
initial: $initial
englishRequired: $englishRequired
city: $city
addres: $addres
}
)
}
mutation UpdateStaff(
$id: UUID!
$userId: String
$fullName: String
$level: String
$role: String
$phone: String
$email: String
$photoUrl: String
$totalShifts: Int
$averageRating: Float
$onTimeRate: Int
$noShowCount: Int
$cancellationCount: Int
$reliabilityScore: Int
$bio: String
$skills: [String!]
$industries: [String!]
$preferredLocations: [String!]
$maxDistanceMiles: Int
$languages: Any
$itemsAttire: Any
$xp: Int
$badges: Any
$isRecommended: Boolean
$ownerId: UUID
$department: DepartmentType
$hubId: UUID
$manager: UUID
$english: EnglishProficiency
$backgroundCheckStatus: BackgroundCheckStatus
$employmentType: EmploymentType
$initial: String
$englishRequired: Boolean
$city: String
$addres: String
) @auth(level: USER) {
staff_update(
id: $id
data: {
userId: $userId
fullName: $fullName
level: $level
role: $role
phone: $phone
email: $email
photoUrl: $photoUrl
totalShifts: $totalShifts
averageRating: $averageRating
onTimeRate: $onTimeRate
noShowCount: $noShowCount
cancellationCount: $cancellationCount
reliabilityScore: $reliabilityScore
bio: $bio
skills: $skills
industries: $industries
preferredLocations: $preferredLocations
maxDistanceMiles: $maxDistanceMiles
languages: $languages
itemsAttire: $itemsAttire
xp: $xp
badges: $badges
isRecommended: $isRecommended
ownerId: $ownerId
department: $department
hubId: $hubId
manager: $manager
english: $english
backgroundCheckStatus: $backgroundCheckStatus
employmentType: $employmentType
initial: $initial
englishRequired: $englishRequired
city: $city
addres: $addres
}
)
}
mutation DeleteStaff($id: UUID!) @auth(level: USER) {
staff_delete(id: $id)
}

175
apps/web/dataconnect/connector/staff/queries.gql Normal file
View File

@@ -0,0 +1,175 @@
query listStaff @auth(level: USER) {
staffs {
id
userId
fullName
level
role
phone
email
photoUrl
totalShifts
averageRating
onTimeRate
noShowCount
cancellationCount
reliabilityScore
xp
badges
isRecommended
bio
skills
industries
preferredLocations
maxDistanceMiles
languages
itemsAttire
ownerId
createdAt
updatedAt
department
hubId
manager
english
backgroundCheckStatus
employmentType
initial
englishRequired
city
addres
}
}
query getStaffById($id: UUID!) @auth(level: USER) {
staff(id: $id) {
id
userId
fullName
role
level
phone
email
photoUrl
totalShifts
averageRating
onTimeRate
noShowCount
cancellationCount
reliabilityScore
xp
badges
isRecommended
bio
skills
industries
preferredLocations
maxDistanceMiles
languages
itemsAttire
ownerId
createdAt
updatedAt
createdBy
department
hubId
manager
english
backgroundCheckStatus
employmentType
initial
englishRequired
city
addres
}
}
query getStaffByUserId($userId: String!) @auth(level: USER) {
staffs(where: { userId: { eq: $userId } }) {
id
userId
fullName
level
phone
email
photoUrl
totalShifts
averageRating
onTimeRate
noShowCount
cancellationCount
reliabilityScore
xp
badges
isRecommended
bio
skills
industries
preferredLocations
maxDistanceMiles
languages
itemsAttire
ownerId
createdAt
updatedAt
createdBy
department
hubId
manager
english
backgroundCheckStatus
employmentType
initial
englishRequired
city
addres
}
}
query filterStaff(
$ownerId: UUID
$fullName: String
$level: String
$email: String
) @auth(level: USER) {
staffs(
where: {
ownerId: { eq: $ownerId }
fullName: { eq: $fullName }
level: { eq: $level }
email: { eq: $email }
}
) {
id
userId
fullName
level
phone
email
photoUrl
averageRating
reliabilityScore
totalShifts
ownerId
isRecommended
skills
industries
backgroundCheckStatus
employmentType
initial
englishRequired
city
addres
}
}

44
apps/web/dataconnect/connector/staffAvailability/mutations.gql Normal file
View File

@@ -0,0 +1,44 @@
mutation createStaffAvailability(
$staffId: UUID!
$day: DayOfWeek!
$slot: AvailabilitySlot!
$status: AvailabilityStatus
$notes: String
) @auth(level: USER) {
staffAvailability_insert(
data: {
staffId: $staffId
day: $day
slot: $slot
status: $status
notes: $notes
}
)
}
mutation updateStaffAvailability(
$staffId: UUID!
$day: DayOfWeek!
$slot: AvailabilitySlot!
$status: AvailabilityStatus
$notes: String
) @auth(level: USER) {
staffAvailability_update(
key: { staffId: $staffId, day: $day, slot: $slot }
data: {
status: $status
notes: $notes
}
)
}
mutation deleteStaffAvailability(
$staffId: UUID!
$day: DayOfWeek!
$slot: AvailabilitySlot!
) @auth(level: USER) {
staffAvailability_delete(
key: { staffId: $staffId, day: $day, slot: $slot }
)
}

87
apps/web/dataconnect/connector/staffAvailability/queries.gql Normal file
View File

@@ -0,0 +1,87 @@
query listStaffAvailabilities(
$offset: Int
$limit: Int
) @auth(level: USER) {
staffAvailabilities(offset: $offset, limit: $limit) {
id
staffId
day
slot
status
notes
createdAt
updatedAt
createdBy
staff { id fullName }
}
}
query listStaffAvailabilitiesByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffAvailabilities(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
) {
id
staffId
day
slot
status
notes
createdAt
updatedAt
createdBy
staff { id fullName }
}
}
query getStaffAvailabilityByKey(
$staffId: UUID!
$day: DayOfWeek!
$slot: AvailabilitySlot!
) @auth(level: USER) {
staffAvailability(key: { staffId: $staffId, day: $day, slot: $slot }) {
id
staffId
day
slot
status
notes
createdAt
updatedAt
createdBy
staff { id fullName }
}
}
query listStaffAvailabilitiesByDay(
$day: DayOfWeek!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffAvailabilities(
where: { day: { eq: $day } }
offset: $offset
limit: $limit
) {
id
staffId
day
slot
status
notes
createdAt
updatedAt
createdBy
staff { id fullName }
}
}

54
apps/web/dataconnect/connector/staffAvailabilityStats/mutations.gql Normal file
View File

@@ -0,0 +1,54 @@
mutation createStaffAvailabilityStats(
$staffId: UUID!
$needWorkIndex: Int
$utilizationPercentage: Int
$predictedAvailabilityScore: Int
$scheduledHoursThisPeriod: Int
$desiredHoursThisPeriod: Int
$lastShiftDate: Timestamp
$acceptanceRate: Int
) @auth(level: USER) {
staffAvailabilityStats_insert(
data: {
staffId: $staffId
needWorkIndex: $needWorkIndex
utilizationPercentage: $utilizationPercentage
predictedAvailabilityScore: $predictedAvailabilityScore
scheduledHoursThisPeriod: $scheduledHoursThisPeriod
desiredHoursThisPeriod: $desiredHoursThisPeriod
lastShiftDate: $lastShiftDate
acceptanceRate: $acceptanceRate
}
)
}
mutation updateStaffAvailabilityStats(
$staffId: UUID!
$needWorkIndex: Int
$utilizationPercentage: Int
$predictedAvailabilityScore: Int
$scheduledHoursThisPeriod: Int
$desiredHoursThisPeriod: Int
$lastShiftDate: Timestamp
$acceptanceRate: Int
) @auth(level: USER) {
staffAvailabilityStats_update(
key: { staffId: $staffId }
data: {
needWorkIndex: $needWorkIndex
utilizationPercentage: $utilizationPercentage
predictedAvailabilityScore: $predictedAvailabilityScore
scheduledHoursThisPeriod: $scheduledHoursThisPeriod
desiredHoursThisPeriod: $desiredHoursThisPeriod
lastShiftDate: $lastShiftDate
acceptanceRate: $acceptanceRate
}
)
}
mutation deleteStaffAvailabilityStats(
$staffId: UUID!
) @auth(level: USER) {
staffAvailabilityStats_delete(key: { staffId: $staffId })
}

109
apps/web/dataconnect/connector/staffAvailabilityStats/queries.gql Normal file
View File

@@ -0,0 +1,109 @@
# ==========================================================
# StaffAvailabilityStats - QUERIES
# ==========================================================
# Notes:
# - Entity key is composite: key: ["staffId"]
# - So the single-record lookup is: staffAvailabilityStats(key: { staffId: ... })
# - There is no Query.staffAvailabilityStat(id: ...) unless you defined id as the key.
# ==========================================================
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listStaffAvailabilityStats(
$offset: Int
$limit: Int
) @auth(level: USER) {
staffAvailabilityStatss(offset: $offset, limit: $limit) {
id
staffId
needWorkIndex
utilizationPercentage
predictedAvailabilityScore
scheduledHoursThisPeriod
desiredHoursThisPeriod
lastShiftDate
acceptanceRate
createdAt
updatedAt
createdBy
staff {
id
fullName
}
}
}
# ----------------------------------------------------------
# GET BY KEY (staffId)
# ----------------------------------------------------------
query getStaffAvailabilityStatsByStaffId(
$staffId: UUID!
) @auth(level: USER) {
staffAvailabilityStats(key: { staffId: $staffId }) {
id
staffId
needWorkIndex
utilizationPercentage
predictedAvailabilityScore
scheduledHoursThisPeriod
desiredHoursThisPeriod
lastShiftDate
acceptanceRate
createdAt
updatedAt
createdBy
staff {
id
fullName
}
}
}
# ----------------------------------------------------------
# FILTER (optional) - useful for dashboards
# NOTE: Data Connect filter ops are typically: eq, ne, gt, ge, lt, le, in, isNull
# ----------------------------------------------------------
query filterStaffAvailabilityStats(
$needWorkIndexMin: Int
$needWorkIndexMax: Int
$utilizationMin: Int
$utilizationMax: Int
$acceptanceRateMin: Int
$acceptanceRateMax: Int
$lastShiftAfter: Timestamp
$lastShiftBefore: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
staffAvailabilityStatss(
where: {
needWorkIndex: { ge: $needWorkIndexMin, le: $needWorkIndexMax }
utilizationPercentage: { ge: $utilizationMin, le: $utilizationMax }
acceptanceRate: { ge: $acceptanceRateMin, le: $acceptanceRateMax }
lastShiftDate: { ge: $lastShiftAfter, le: $lastShiftBefore }
}
offset: $offset
limit: $limit
) {
id
staffId
needWorkIndex
utilizationPercentage
predictedAvailabilityScore
scheduledHoursThisPeriod
desiredHoursThisPeriod
lastShiftDate
acceptanceRate
createdAt
updatedAt
createdBy
staff {
id
fullName
}
}
}

47
apps/web/dataconnect/connector/staffCourse/mutations.gql Normal file
View File

@@ -0,0 +1,47 @@
# Mutations for StaffCourse
mutation createStaffCourse(
$staffId: UUID!
$courseId: UUID!
$progressPercent: Int
$completed: Boolean
$completedAt: Timestamp
$startedAt: Timestamp
$lastAccessedAt: Timestamp
) @auth(level: USER) {
staffCourse_insert(
data: {
staffId: $staffId
courseId: $courseId
progressPercent: $progressPercent
completed: $completed
completedAt: $completedAt
startedAt: $startedAt
lastAccessedAt: $lastAccessedAt
}
)
}
mutation updateStaffCourse(
$id: UUID!
$progressPercent: Int
$completed: Boolean
$completedAt: Timestamp
$startedAt: Timestamp
$lastAccessedAt: Timestamp
) @auth(level: USER) {
staffCourse_update(
id: $id
data: {
progressPercent: $progressPercent
completed: $completed
completedAt: $completedAt
startedAt: $startedAt
lastAccessedAt: $lastAccessedAt
}
)
}
mutation deleteStaffCourse($id: UUID!) @auth(level: USER) {
staffCourse_delete(id: $id)
}

85
apps/web/dataconnect/connector/staffCourse/queries.gql Normal file
View File

@@ -0,0 +1,85 @@
query getStaffCourseById($id: UUID!) @auth(level: USER) {
staffCourse(id: $id) {
id
staffId
courseId
progressPercent
completed
completedAt
startedAt
lastAccessedAt
createdAt
updatedAt
}
}
query listStaffCoursesByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffCourses(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
) {
id
staffId
courseId
progressPercent
completed
completedAt
startedAt
lastAccessedAt
createdAt
updatedAt
}
}
query listStaffCoursesByCourseId(
$courseId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffCourses(
where: { courseId: { eq: $courseId } }
offset: $offset
limit: $limit
) {
id
staffId
courseId
progressPercent
completed
completedAt
startedAt
lastAccessedAt
createdAt
updatedAt
}
}
query getStaffCourseByStaffAndCourse(
$staffId: UUID!
$courseId: UUID!
) @auth(level: USER) {
staffCourses(
where: {
staffId: { eq: $staffId }
courseId: { eq: $courseId }
}
limit: 1
) {
id
staffId
courseId
progressPercent
completed
completedAt
startedAt
lastAccessedAt
createdAt
updatedAt
}
}

43
apps/web/dataconnect/connector/staffDocument/mutations.gql Normal file
View File

@@ -0,0 +1,43 @@
mutation createStaffDocument(
$staffId: UUID!
$staffName: String!
$documentId: UUID!
$status: DocumentStatus!
$documentUrl: String
$expiryDate: Timestamp
) @auth(level: USER) {
staffDocument_insert(
data: {
staffId: $staffId
staffName: $staffName
documentId: $documentId
status: $status
documentUrl: $documentUrl
expiryDate: $expiryDate
}
)
}
mutation updateStaffDocument(
$staffId: UUID!
$documentId: UUID!
$status: DocumentStatus
$documentUrl: String
$expiryDate: Timestamp
) @auth(level: USER) {
staffDocument_update(
key: { staffId: $staffId, documentId: $documentId }
data: {
status: $status
documentUrl: $documentUrl
}
)
}
mutation deleteStaffDocument(
$staffId: UUID!
$documentId: UUID!
) @auth(level: USER) {
staffDocument_delete(key: { staffId: $staffId, documentId: $documentId })
}

100
apps/web/dataconnect/connector/staffDocument/queries.gql Normal file
View File

@@ -0,0 +1,100 @@
query getStaffDocumentByKey(
$staffId: UUID!
$documentId: UUID!
) @auth(level: USER) {
staffDocument(key: { staffId: $staffId, documentId: $documentId }) {
id
staffId
staffName
documentId
status
documentUrl
expiryDate
createdAt
updatedAt
document {
id
name
documentType
description
}
}
}
query listStaffDocumentsByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffDocuments(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
) {
id
staffId
staffName
documentId
status
documentUrl
expiryDate
createdAt
updatedAt
document {
id
name
documentType
}
}
}
query listStaffDocumentsByDocumentType(
$documentType: DocumentType!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffDocuments(
where: { document: { documentType: { eq: $documentType } } }
offset: $offset
limit: $limit
) {
id
staffId
staffName
documentId
status
documentUrl
expiryDate
document {
id
name
documentType
}
}
}
query listStaffDocumentsByStatus(
$status: DocumentStatus!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffDocuments(
where: { status: { eq: $status } }
offset: $offset
limit: $limit
) {
id
staffId
staffName
documentId
status
documentUrl
expiryDate
document {
id
name
documentType
}
}
}

22
apps/web/dataconnect/connector/staffRole/mutations.gql Normal file
View File

@@ -0,0 +1,22 @@
mutation createStaffRole(
$staffId: UUID!
$roleId: UUID!
$roleType: RoleType
) @auth(level: USER) {
staffRole_insert(
data: {
staffId: $staffId
roleId: $roleId
roleType: $roleType
}
)
}
mutation deleteStaffRole(
$staffId: UUID!
$roleId: UUID!
) @auth(level: USER) {
staffRole_delete(
key: { staffId: $staffId, roleId: $roleId }
)
}

142
apps/web/dataconnect/connector/staffRole/queries.gql Normal file
View File

@@ -0,0 +1,142 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listStaffRoles(
$offset: Int
$limit: Int
) @auth(level: USER) {
staffRoles(offset: $offset, limit: $limit) {
id
staffId
roleId
createdAt
roleType
staff {
id
fullName
userId
email
phone
}
role {
id
name
costPerHour
}
}
}
# ----------------------------------------------------------
# GET BY COMPOSITE KEY (staffId + roleId)
# ----------------------------------------------------------
query getStaffRoleByKey(
$staffId: UUID!
$roleId: UUID!
) @auth(level: USER) {
staffRole(key: { staffId: $staffId, roleId: $roleId }) {
id
staffId
roleId
createdAt
roleType
staff {
id
fullName
userId
email
phone
}
role {
id
name
costPerHour
}
}
}
# ----------------------------------------------------------
# LIST BY STAFF (most common)
# ----------------------------------------------------------
query listStaffRolesByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffRoles(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
) {
id
staffId
roleId
createdAt
roleType
role {
id
name
costPerHour
}
}
}
# ----------------------------------------------------------
# LIST BY ROLE (who has this skill)
# ----------------------------------------------------------
query listStaffRolesByRoleId(
$roleId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
staffRoles(
where: { roleId: { eq: $roleId } }
offset: $offset
limit: $limit
) {
id
staffId
roleId
createdAt
roleType
staff {
id
fullName
userId
email
phone
}
}
}
# ----------------------------------------------------------
# FILTER (optional)
# Useful when you want both conditions without using key lookup
# ----------------------------------------------------------
query filterStaffRoles(
$staffId: UUID
$roleId: UUID
$offset: Int
$limit: Int
) @auth(level: USER) {
staffRoles(
where: {
staffId: { eq: $staffId }
roleId: { eq: $roleId }
}
offset: $offset
limit: $limit
) {
id
staffId
roleId
createdAt
roleType
}
}

64
apps/web/dataconnect/connector/task/mutations.gql Normal file
View File

@@ -0,0 +1,64 @@
mutation createTask(
$taskName: String!
$description: String
$priority: TaskPriority!
$status: TaskStatus!
$dueDate: Timestamp
$progress: Int
$orderIndex: Int
$commentCount: Int
$attachmentCount: Int
$files: Any
$ownerId:UUID!
) @auth(level: USER) {
task_insert(
data: {
taskName: $taskName
description: $description
priority: $priority
status: $status
dueDate: $dueDate
progress: $progress
orderIndex: $orderIndex
commentCount: $commentCount
attachmentCount: $attachmentCount
files: $files
ownerId:$ownerId
}
)
}
mutation updateTask(
$id: UUID!
$taskName: String
$description: String
$priority: TaskPriority
$status: TaskStatus
$dueDate: Timestamp
$progress: Int
$assignedMembers: Any
$orderIndex: Int
$commentCount: Int
$attachmentCount: Int
$files: Any
) @auth(level: USER) {
task_update(
id: $id
data: {
taskName: $taskName
description: $description
priority: $priority
status: $status
dueDate: $dueDate
progress: $progress
orderIndex: $orderIndex
commentCount: $commentCount
attachmentCount: $attachmentCount
files: $files
}
)
}
mutation deleteTask($id: UUID!) @auth(level: USER) {
task_delete(id: $id)
}

83
apps/web/dataconnect/connector/task/queries.gql Normal file
View File

@@ -0,0 +1,83 @@
query listTasks @auth(level: USER) {
tasks {
id
taskName
description
priority
status
dueDate
progress
orderIndex
commentCount
attachmentCount
files
createdAt
updatedAt
createdBy
}
}
query getTaskById($id: UUID!) @auth(level: USER) {
task(id: $id) {
id
taskName
description
priority
status
dueDate
progress
orderIndex
commentCount
attachmentCount
files
createdAt
updatedAt
createdBy
}
}
query getTasksByOwnerId($ownerId: UUID!) @auth(level: USER) {
tasks(where: { ownerId: { eq: $ownerId } }) {
id
taskName
description
priority
status
dueDate
progress
orderIndex
commentCount
attachmentCount
files
createdAt
updatedAt
createdBy
}
}
query filterTasks(
$status: TaskStatus
$priority: TaskPriority
) @auth(level: USER) {
tasks(
where: {
status: { eq: $status }
priority: { eq: $priority }
}
) {
id
taskName
description
priority
status
dueDate
progress
orderIndex
commentCount
attachmentCount
files
createdAt
updatedAt
createdBy
}
}

33
apps/web/dataconnect/connector/task_comment/mutations.gql Normal file
View File

@@ -0,0 +1,33 @@
mutation createTaskComment(
$taskId: UUID!
$teamMemberId: UUID!
$comment: String!
$isSystem: Boolean
) @auth(level: USER) {
taskComment_insert(
data: {
taskId: $taskId
teamMemberId: $teamMemberId
comment: $comment
isSystem: $isSystem
}
)
}
mutation updateTaskComment(
$id: UUID!
$comment: String
$isSystem: Boolean
) @auth(level: USER) {
taskComment_update(
id: $id
data: {
comment: $comment
isSystem: $isSystem
}
)
}
mutation deleteTaskComment($id: UUID!) @auth(level: USER) {
taskComment_delete(id: $id)
}

62
apps/web/dataconnect/connector/task_comment/queries.gql Normal file
View File

@@ -0,0 +1,62 @@
query listTaskComments @auth(level: USER) {
taskComments {
id
taskId
teamMemberId
comment
isSystem
createdAt
teamMember{
user {
fullName
email
}
}
}
}
query getTaskCommentById($id: UUID!) @auth(level: USER) {
taskComment(id: $id) {
id
taskId
teamMemberId
comment
isSystem
createdAt
teamMember{
user {
fullName
email
}
}
}
}
query getTaskCommentsByTaskId($taskId: UUID!) @auth(level: USER) {
taskComments(where: { taskId: { eq: $taskId } }) {
id
taskId
teamMemberId
comment
isSystem
createdAt
teamMember{
user {
fullName
email
}
}
}
}

45
apps/web/dataconnect/connector/taxForm/mutations.gql Normal file
View File

@@ -0,0 +1,45 @@
mutation createTaxForm(
$formType: TaxFormType!
$title: String!
$subtitle: String
$description: String
$status: TaxFormStatus
$staffId: UUID!
$formData: Any
) @auth(level: USER) {
taxForm_insert(
data: {
formType: $formType
title: $title
subtitle: $subtitle
description: $description
status: $status
staffId: $staffId
formData: $formData
}
)
}
mutation updateTaxForm(
$id: UUID!
$status: TaxFormStatus
$formData: Any
$title: String
$subtitle: String
$description: String
) @auth(level: USER) {
taxForm_update(
id: $id
data: {
status: $status
formData: $formData
title: $title
subtitle: $subtitle
description: $description
}
)
}
mutation deleteTaxForm($id: UUID!) @auth(level: USER) {
taxForm_delete(id: $id)
}

67
apps/web/dataconnect/connector/taxForm/queries.gql Normal file
View File

@@ -0,0 +1,67 @@
query listTaxForms @auth(level: USER) {
taxForms {
id
formType
title
subtitle
description
status
staffId
formData
createdAt
updatedAt
createdBy
}
}
query getTaxFormById($id: UUID!) @auth(level: USER) {
taxForm(id: $id) {
id
formType
title
subtitle
description
status
staffId
formData
createdAt
updatedAt
createdBy
}
}
query getTaxFormsBystaffId($staffId: UUID!) @auth(level: USER) {
taxForms(where: { staffId: { eq: $staffId } }) {
id
formType
title
subtitle
description
status
staffId
formData
createdAt
updatedAt
createdBy
}
}
query filterTaxForms(
$formType: TaxFormType
$status: TaxFormStatus
$staffId: UUID
) @auth(level: USER) {
taxForms(
where: {
formType: { eq: $formType }
status: { eq: $status }
staffId: { eq: $staffId }
}
) {
id
formType
title
status
staffId
}
}

73
apps/web/dataconnect/connector/team/mutations.gql Normal file
View File

@@ -0,0 +1,73 @@
mutation createTeam(
$teamName: String!
$ownerId: UUID!
$ownerName: String!
$ownerRole: String!
$email: String
$companyLogo: String
$totalMembers: Int
$activeMembers: Int
$totalHubs: Int
$departments: Any
$favoriteStaffCount: Int
$blockedStaffCount: Int
$favoriteStaff: Any
$blockedStaff: Any
) @auth(level: USER) {
team_insert(
data: {
teamName: $teamName
ownerId: $ownerId
ownerName: $ownerName
ownerRole: $ownerRole
email: $email
companyLogo: $companyLogo
totalMembers: $totalMembers
activeMembers: $activeMembers
totalHubs: $totalHubs
departments: $departments
favoriteStaffCount: $favoriteStaffCount
blockedStaffCount: $blockedStaffCount
favoriteStaff: $favoriteStaff
blockedStaff: $blockedStaff
}
)
}
mutation updateTeam(
$id: UUID!
$teamName: String
$ownerName: String
$ownerRole: String
$companyLogo: String
$totalMembers: Int
$activeMembers: Int
$totalHubs: Int
$departments: Any
$favoriteStaffCount: Int
$blockedStaffCount: Int
$favoriteStaff: Any
$blockedStaff: Any
) @auth(level: USER) {
team_update(
id: $id
data: {
teamName: $teamName
ownerName: $ownerName
ownerRole: $ownerRole
companyLogo: $companyLogo
totalMembers: $totalMembers
activeMembers: $activeMembers
totalHubs: $totalHubs
departments: $departments
favoriteStaffCount: $favoriteStaffCount
blockedStaffCount: $blockedStaffCount
favoriteStaff: $favoriteStaff
blockedStaff: $blockedStaff
}
)
}
mutation deleteTeam($id: UUID!) @auth(level: USER) {
team_delete(id: $id)
}

68
apps/web/dataconnect/connector/team/queries.gql Normal file
View File

@@ -0,0 +1,68 @@
query listTeams @auth(level: USER) {
teams {
id
teamName
ownerId
ownerName
ownerRole
email
companyLogo
totalMembers
activeMembers
totalHubs
departments
favoriteStaffCount
blockedStaffCount
favoriteStaff
blockedStaff
createdAt
updatedAt
createdBy
}
}
query getTeamById($id: UUID!) @auth(level: USER) {
team(id: $id) {
id
teamName
ownerId
ownerName
ownerRole
email
companyLogo
totalMembers
activeMembers
totalHubs
departments
favoriteStaffCount
blockedStaffCount
favoriteStaff
blockedStaff
createdAt
updatedAt
createdBy
}
}
query getTeamsByOwnerId($ownerId: UUID!) @auth(level: USER) {
teams(where: { ownerId: { eq: $ownerId } }) {
id
teamName
ownerId
ownerName
ownerRole
email
companyLogo
totalMembers
activeMembers
totalHubs
departments
favoriteStaffCount
blockedStaffCount
favoriteStaff
blockedStaff
createdAt
updatedAt
createdBy
}
}

55
apps/web/dataconnect/connector/teamHub/mutations.gql Normal file
View File

@@ -0,0 +1,55 @@
mutation createTeamHub(
$teamId: UUID!
$hubName: String!
$address: String!
$city: String
$state: String
$zipCode: String
$managerName: String
$isActive: Boolean
$departments: Any
) @auth(level: USER) {
teamHub_insert(
data: {
teamId: $teamId
hubName: $hubName
address: $address
city: $city
state: $state
zipCode: $zipCode
managerName: $managerName
isActive: $isActive
departments: $departments
}
)
}
mutation updateTeamHub(
$id: UUID!
$hubName: String
$address: String
$city: String
$state: String
$zipCode: String
$managerName: String
$isActive: Boolean
$departments: Any
) @auth(level: USER) {
teamHub_update(
id: $id
data: {
hubName: $hubName
address: $address
city: $city
state: $state
zipCode: $zipCode
managerName: $managerName
isActive: $isActive
departments: $departments
}
)
}
mutation deleteTeamHub($id: UUID!) @auth(level: USER) {
teamHub_delete(id: $id)
}

80
apps/web/dataconnect/connector/teamHub/queries.gql Normal file
View File

@@ -0,0 +1,80 @@
query listTeamHubs @auth(level: USER) {
teamHubs {
id
teamId
hubName
address
city
state
zipCode
managerName
isActive
departments
createdAt
updatedAt
createdBy
}
}
query getTeamHubById($id: UUID!) @auth(level: USER) {
teamHub(id: $id) {
id
teamId
hubName
address
city
state
zipCode
managerName
isActive
departments
createdAt
updatedAt
createdBy
}
}
query getTeamHubsByTeamId($teamId: UUID!) @auth(level: USER) {
teamHubs(where: { teamId: { eq: $teamId } }) {
id
teamId
hubName
address
city
state
zipCode
managerName
isActive
departments
createdAt
updatedAt
createdBy
}
}
# ------------------------------------------------------------
# LIST TEAM HUBS BY OWNER (Vendor/Business)
# ------------------------------------------------------------
query listTeamHubsByOwnerId(
$ownerId: UUID!
) @auth(level: USER) {
teamHubs(
where: {
team: {
ownerId: { eq: $ownerId }
}
}
) {
id
teamId
hubName
address
city
state
zipCode
managerName
isActive
departments
createdAt
}
}

35
apps/web/dataconnect/connector/teamHudDeparment/mutations.gql Normal file
View File

@@ -0,0 +1,35 @@
mutation createTeamHudDepartment(
$name: String!
$costCenter: String
$teamHubId: UUID!
) @auth(level: USER) {
teamHudDepartment_insert(
data: {
name: $name
costCenter: $costCenter
teamHubId: $teamHubId
}
)
}
mutation updateTeamHudDepartment(
$id: UUID!
$name: String
$costCenter: String
$teamHubId: UUID
) @auth(level: USER) {
teamHudDepartment_update(
id: $id
data: {
name: $name
costCenter: $costCenter
teamHubId: $teamHubId
}
)
}
mutation deleteTeamHudDepartment($id: UUID!) @auth(level: USER) {
teamHudDepartment_delete(id: $id)
}

68
apps/web/dataconnect/connector/teamHudDeparment/queries.gql Normal file
View File

@@ -0,0 +1,68 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listTeamHudDepartments(
$offset: Int
$limit: Int
) @auth(level: USER) {
teamHudDepartments(offset: $offset, limit: $limit) {
id
name
costCenter
teamHubId
teamHub {
id
hubName
}
createdAt
}
}
# ----------------------------------------------------------
# GET BY ID
# ----------------------------------------------------------
query getTeamHudDepartmentById($id: UUID!) @auth(level: USER) {
teamHudDepartment(id: $id) {
id
name
costCenter
teamHubId
teamHub {
id
hubName
}
createdAt
}
}
# ----------------------------------------------------------
# LIST BY TEAM HUB ID
# ----------------------------------------------------------
query listTeamHudDepartmentsByTeamHubId(
$teamHubId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
teamHudDepartments(
where: { teamHubId: { eq: $teamHubId } }
offset: $offset
limit: $limit
) {
id
name
costCenter
teamHubId
teamHub {
id
hubName
}
createdAt
}
}

92
apps/web/dataconnect/connector/teamMember/mutations.gql Normal file
View File

@@ -0,0 +1,92 @@
mutation createTeamMember(
$teamId: UUID!
$role: TeamMemberRole!
$title: String
$department: String
$teamHubId: UUID
$isActive: Boolean
$userId: String!
$inviteStatus: TeamMemberInviteStatus
) @auth(level: USER) {
teamMember_insert(
data: {
teamId: $teamId
role: $role
title: $title
department: $department
teamHubId: $teamHubId
isActive: $isActive
userId: $userId
inviteStatus: $inviteStatus
}
)
}
mutation updateTeamMember(
$id: UUID!
$role: TeamMemberRole
$title: String
$department: String
$teamHubId: UUID
$isActive: Boolean
$inviteStatus: TeamMemberInviteStatus
) @auth(level: USER) {
teamMember_update(
id: $id
data: {
role: $role
title: $title
department: $department
teamHubId: $teamHubId
isActive: $isActive
inviteStatus: $inviteStatus
}
)
}
mutation updateTeamMemberInviteStatus(
$id: UUID!
$inviteStatus: TeamMemberInviteStatus!
) @auth(level: USER) {
teamMember_update(
id: $id
data: {
inviteStatus: $inviteStatus
}
)
}
mutation acceptInviteByCode(
$inviteCode: UUID!
) @auth(level: USER) {
teamMember_updateMany(
where: {
inviteCode: { eq: $inviteCode }
inviteStatus: { eq: PENDING }
}
data: {
inviteStatus: ACCEPTED
isActive: true
}
)
}
mutation cancelInviteByCode(
$inviteCode: UUID!
) @auth(level: USER) {
teamMember_updateMany(
where: {
inviteCode: { eq: $inviteCode }
inviteStatus: { eq: PENDING }
}
data: {
inviteStatus: CANCELLED
isActive: false
}
)
}
mutation deleteTeamMember($id: UUID!) @auth(level: USER) {
teamMember_delete(id: $id)
}

66
apps/web/dataconnect/connector/teamMember/queries.gql Normal file
View File

@@ -0,0 +1,66 @@
query listTeamMembers @auth(level: USER) {
teamMembers {
id
teamId
role
title
department
teamHubId
isActive
createdAt
user {
fullName
email
}
teamHub{
hubName
}
}
}
query getTeamMemberById($id: UUID!) @auth(level: USER) {
teamMember(id: $id) {
id
teamId
role
title
department
teamHubId
isActive
createdAt
user {
fullName
email
}
teamHub{
hubName
}
}
}
query getTeamMembersByTeamId($teamId: UUID!) @auth(level: USER) {
teamMembers(where: { teamId: { eq: $teamId } }) {
id
teamId
role
title
department
teamHubId
isActive
createdAt
user {
fullName
email
}
teamHub{
hubName
}
}
}

45
apps/web/dataconnect/connector/user/mutations.gql Normal file
View File

@@ -0,0 +1,45 @@
mutation CreateUser(
$id: String!, # Firebase UID
$email: String,
$fullName: String,
$role: UserBaseRole!,
$userRole: String,
$photoUrl: String
) @auth(level: USER) {
user_insert(
data: {
id: $id
email: $email
fullName: $fullName
role: $role
userRole: $userRole
photoUrl: $photoUrl
}
)
}
mutation UpdateUser(
$id: String!,
$email: String,
$fullName: String,
$role: UserBaseRole,
$userRole: String,
$photoUrl: String
) @auth(level: USER) {
user_update(
id: $id,
data: {
email: $email
fullName: $fullName
role: $role
userRole: $userRole
photoUrl: $photoUrl
}
)
}
mutation DeleteUser(
$id: String!
) @auth(level: USER) {
user_delete(id: $id)
}

48
apps/web/dataconnect/connector/user/queries.gql Normal file
View File

@@ -0,0 +1,48 @@
query listUsers @auth(level: USER) {
users {
id
email
fullName
role
userRole
photoUrl
createdDate
updatedDate
}
}
query getUserById(
$id: String!
) @auth(level: USER) {
user(id: $id) {
id
email
fullName
role
userRole
photoUrl
}
}
query filterUsers(
$id: String,
$email: String,
$role: UserBaseRole,
$userRole: String
) @auth(level: USER) {
users(
where: {
id: { eq: $id }
email: { eq: $email }
role: { eq: $role }
userRole: { eq: $userRole }
}
) {
id
email
fullName
role
userRole
photoUrl
}
}

74
apps/web/dataconnect/connector/userConversation/mutations.gql Normal file
View File

@@ -0,0 +1,74 @@
mutation createUserConversation(
$conversationId: UUID!
$userId: String!
$unreadCount: Int
$lastReadAt: Timestamp
) @auth(level: USER) {
userConversation_insert(
data: {
conversationId: $conversationId
userId: $userId
unreadCount: $unreadCount
lastReadAt: $lastReadAt
}
)
}
mutation updateUserConversation(
$conversationId: UUID!
$userId: String!
$unreadCount: Int
$lastReadAt: Timestamp
) @auth(level: USER) {
userConversation_update(
key: { conversationId: $conversationId, userId: $userId }
data: {
unreadCount: $unreadCount
lastReadAt: $lastReadAt
}
)
}
# ----------------------------------------------------------
# MARK AS READ (sets unreadCount=0 + lastReadAt=now)
# Note: request.time is valid in schema defaults; in mutations
# you can pass Timestamp from client. If you want "now" server-side,
# you'd typically pass null and have logic elsewhere.
# ----------------------------------------------------------
mutation markConversationAsRead(
$conversationId: UUID!
$userId: String!
$lastReadAt: Timestamp
) @auth(level: USER) {
userConversation_update(
key: { conversationId: $conversationId, userId: $userId }
data: {
unreadCount: 0
lastReadAt: $lastReadAt
}
)
}
# ----------------------------------------------------------
# INCREMENT UNREAD (common after sending message)
# ----------------------------------------------------------
mutation incrementUnreadForUser(
$conversationId: UUID!
$userId: String!
$unreadCount: Int!
) @auth(level: USER) {
userConversation_update(
key: { conversationId: $conversationId, userId: $userId }
data: { unreadCount: $unreadCount }
)
}
mutation deleteUserConversation(
$conversationId: UUID!
$userId: String!
) @auth(level: USER) {
userConversation_delete(
key: { conversationId: $conversationId, userId: $userId }
)
}

230
apps/web/dataconnect/connector/userConversation/queries.gql Normal file
View File

@@ -0,0 +1,230 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listUserConversations(
$offset: Int
$limit: Int
) @auth(level: USER) {
userConversations(offset: $offset, limit: $limit) {
id
conversationId
userId
unreadCount
lastReadAt
createdAt
conversation {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
user {
id
fullName
photoUrl
}
}
}
# ----------------------------------------------------------
# GET BY KEY (conversationId + userId)
# ----------------------------------------------------------
query getUserConversationByKey(
$conversationId: UUID!
$userId: String!
) @auth(level: USER) {
userConversation(key: { conversationId: $conversationId, userId: $userId }) {
id
conversationId
userId
unreadCount
lastReadAt
createdAt
conversation {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
user {
id
fullName
photoUrl
}
}
}
# ----------------------------------------------------------
# LIST BY USER (My inbox) ✅
# Order by most recent activity (Conversation.lastMessageAt)
# NOTE: If your DC version doesn't allow orderBy on nested fields,
# just orderBy createdAt/updatedAt on user_conversations.
# ----------------------------------------------------------
query listUserConversationsByUserId(
$userId: String!
$offset: Int
$limit: Int
) @auth(level: USER) {
userConversations(
where: { userId: { eq: $userId } }
offset: $offset
limit: $limit
# If supported:
# orderBy: { conversation: { lastMessageAt: DESC } }
orderBy: { updatedAt: DESC }
) {
id
conversationId
userId
unreadCount
lastReadAt
createdAt
updatedAt
createdBy
conversation {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
user {
id
fullName
photoUrl
}
}
}
# ----------------------------------------------------------
# LIST UNREAD BY USER (badge, notifications)
# ----------------------------------------------------------
query listUnreadUserConversationsByUserId(
$userId: String!
$offset: Int
$limit: Int
) @auth(level: USER) {
userConversations(
where: {
userId: { eq: $userId }
unreadCount: { gt: 0 }
}
offset: $offset
limit: $limit
orderBy: { updatedAt: DESC }
) {
id
conversationId
userId
unreadCount
lastReadAt
createdAt
conversation {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
}
}
}
# ----------------------------------------------------------
# LIST BY CONVERSATION (participants view)
# ----------------------------------------------------------
query listUserConversationsByConversationId(
$conversationId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
userConversations(
where: { conversationId: { eq: $conversationId } }
offset: $offset
limit: $limit
orderBy: { createdAt: ASC }
) {
id
conversationId
userId
unreadCount
lastReadAt
createdAt
user {
id
fullName
photoUrl
}
}
}
# ----------------------------------------------------------
# FILTER (dashboard/debug)
# ----------------------------------------------------------
query filterUserConversations(
$userId: String
$conversationId: UUID
$unreadMin: Int
$unreadMax: Int
$lastReadAfter: Timestamp
$lastReadBefore: Timestamp
$offset: Int
$limit: Int
) @auth(level: USER) {
userConversations(
where: {
userId: { eq: $userId }
conversationId: { eq: $conversationId }
unreadCount: { ge: $unreadMin, le: $unreadMax }
lastReadAt: { ge: $lastReadAfter, le: $lastReadBefore }
}
offset: $offset
limit: $limit
orderBy: { updatedAt: DESC }
) {
id
conversationId
userId
unreadCount
lastReadAt
createdAt
conversation {
id
subject
status
conversationType
isGroup
groupName
lastMessage
lastMessageAt
createdAt
}
user { id fullName photoUrl }
}
}

99
apps/web/dataconnect/connector/vendor/mutations.gql vendored Normal file
View File

@@ -0,0 +1,99 @@
mutation createVendor(
$userId: String!
$companyName: String!
$email: String
$phone: String
$photoUrl: String
$address: String
$billingAddress: String
$timezone: String
$legalName: String
$doingBusinessAs: String
$region: String
$state: String
$city: String
$serviceSpecialty: String
$approvalStatus: ApprovalStatus
$isActive: Boolean
$markup: Float
$fee: Float
$csat: Float
$tier: VendorTier
) @auth(level: USER) {
vendor_insert(
data: {
userId: $userId
companyName: $companyName
email: $email
phone: $phone
photoUrl: $photoUrl
address: $address
billingAddress: $billingAddress
timezone: $timezone
legalName: $legalName
doingBusinessAs: $doingBusinessAs
region: $region
state: $state
city: $city
serviceSpecialty: $serviceSpecialty
approvalStatus: $approvalStatus
isActive: $isActive
markup: $markup
fee: $fee
csat: $csat
tier: $tier
}
)
}
mutation updateVendor(
$id: UUID!
$companyName: String
$email: String
$phone: String
$photoUrl: String
$address: String
$billingAddress: String
$timezone: String
$legalName: String
$doingBusinessAs: String
$region: String
$state: String
$city: String
$serviceSpecialty: String
$approvalStatus: ApprovalStatus
$isActive: Boolean
$markup: Float
$fee: Float
$csat: Float
$tier: VendorTier
) @auth(level: USER) {
vendor_update(
id: $id
data: {
companyName: $companyName
email: $email
phone: $phone
photoUrl: $photoUrl
address: $address
billingAddress: $billingAddress
timezone: $timezone
legalName: $legalName
doingBusinessAs: $doingBusinessAs
region: $region
state: $state
city: $city
serviceSpecialty: $serviceSpecialty
approvalStatus: $approvalStatus
isActive: $isActive
markup: $markup
fee: $fee
csat: $csat
tier: $tier
}
)
}
mutation deleteVendor($id: UUID!) @auth(level: USER) {
vendor_delete(id: $id)
}

86
apps/web/dataconnect/connector/vendor/queries.gql vendored Normal file
View File

@@ -0,0 +1,86 @@
query getVendorById($id: UUID!) @auth(level: USER) {
vendor(id: $id) {
id
userId
companyName
email
phone
photoUrl
address
billingAddress
timezone
legalName
doingBusinessAs
region
state
city
serviceSpecialty
approvalStatus
isActive
markup
fee
csat
tier
createdAt
updatedAt
createdBy
}
}
query getVendorByUserId($userId: String!) @auth(level: USER) {
vendors(where: { userId: { eq: $userId } }) {
id
userId
companyName
email
phone
photoUrl
address
billingAddress
timezone
legalName
doingBusinessAs
region
state
city
serviceSpecialty
approvalStatus
isActive
markup
fee
csat
tier
createdAt
updatedAt
createdBy
}
}
query listVendors @auth(level: USER) {
vendors {
id
userId
companyName
email
phone
photoUrl
address
billingAddress
timezone
legalName
doingBusinessAs
region
state
city
serviceSpecialty
approvalStatus
isActive
markup
fee
csat
tier
createdAt
updatedAt
createdBy
}
}

48
apps/web/dataconnect/connector/vendorBenefitPlan/mutations.gql Normal file
View File

@@ -0,0 +1,48 @@
mutation createVendorBenefitPlan(
$vendorId: UUID!
$title: String!
$description: String
$requestLabel: String
$total: Int
$isActive: Boolean
$createdBy: String
) @auth(level: USER) {
vendorBenefitPlan_insert(
data: {
vendorId: $vendorId
title: $title
description: $description
requestLabel: $requestLabel
total: $total
isActive: $isActive
}
)
}
mutation updateVendorBenefitPlan(
$id: UUID!
$vendorId: UUID
$title: String
$description: String
$requestLabel: String
$total: Int
$isActive: Boolean
$createdBy: String
) @auth(level: USER) {
vendorBenefitPlan_update(
id: $id
data: {
vendorId: $vendorId
title: $title
description: $description
requestLabel: $requestLabel
total: $total
isActive: $isActive
}
)
}
mutation deleteVendorBenefitPlan($id: UUID!) @auth(level: USER) {
vendorBenefitPlan_delete(id: $id)
}

149
apps/web/dataconnect/connector/vendorBenefitPlan/queries.gql Normal file
View File

@@ -0,0 +1,149 @@
# ----------------------------------------------------------
# LIST ALL (admin/debug)
# ----------------------------------------------------------
query listVendorBenefitPlans(
$offset: Int
$limit: Int
) @auth(level: USER) {
vendorBenefitPlans(
offset: $offset
limit: $limit
) {
id
vendorId
title
description
requestLabel
total
isActive
createdAt
updatedAt
createdBy
vendor {
companyName
}
}
}
# ----------------------------------------------------------
# GET BY ID
# ----------------------------------------------------------
query getVendorBenefitPlanById($id: UUID!) @auth(level: USER) {
vendorBenefitPlan(id: $id) {
id
vendorId
title
description
requestLabel
total
isActive
createdAt
updatedAt
createdBy
vendor {
companyName
}
}
}
# ----------------------------------------------------------
# LIST BY VENDOR
# ----------------------------------------------------------
query listVendorBenefitPlansByVendorId(
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
vendorBenefitPlans(
where: { vendorId: { eq: $vendorId } }
offset: $offset
limit: $limit
) {
id
vendorId
title
description
requestLabel
total
isActive
createdAt
updatedAt
createdBy
vendor {
companyName
}
}
}
# ----------------------------------------------------------
# LIST ACTIVE PLANS BY VENDOR
# ----------------------------------------------------------
query listActiveVendorBenefitPlansByVendorId(
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
vendorBenefitPlans(
where: {
vendorId: { eq: $vendorId }
isActive: { eq: true }
}
offset: $offset
limit: $limit
) {
id
vendorId
title
description
requestLabel
total
isActive
createdAt
updatedAt
createdBy
vendor {
companyName
}
}
}
# ----------------------------------------------------------
# FILTER (vendorId + title + isActive)
# - Useful for "does this plan already exist?"
# ----------------------------------------------------------
query filterVendorBenefitPlans(
$vendorId: UUID
$title: String
$isActive: Boolean
$offset: Int
$limit: Int
) @auth(level: USER) {
vendorBenefitPlans(
where: {
vendorId: { eq: $vendorId }
title: { eq: $title }
isActive: { eq: $isActive }
}
offset: $offset
limit: $limit
) {
id
vendorId
title
description
requestLabel
total
isActive
createdAt
updatedAt
createdBy
vendor {
companyName
}
}
}

57
apps/web/dataconnect/connector/vendorRate/mutations.gql Normal file
View File

@@ -0,0 +1,57 @@
mutation createVendorRate(
$vendorId: UUID!,
$roleName: String,
$category: CategoryType,
$clientRate: Float,
$employeeWage: Float,
$markupPercentage: Float,
$vendorFeePercentage: Float,
$isActive: Boolean,
$notes: String
) @auth(level: USER) {
vendorRate_insert(
data: {
vendorId: $vendorId,
roleName: $roleName,
category: $category,
clientRate: $clientRate,
employeeWage: $employeeWage,
markupPercentage: $markupPercentage,
vendorFeePercentage: $vendorFeePercentage,
isActive: $isActive,
notes: $notes,
}
)
}
mutation updateVendorRate(
$id: UUID!,
$vendorId: UUID,
$roleName: String,
$category: CategoryType,
$clientRate: Float,
$employeeWage: Float,
$markupPercentage: Float,
$vendorFeePercentage: Float,
$isActive: Boolean,
$notes: String,
) @auth(level: USER) {
vendorRate_update(
id: $id,
data: {
vendorId: $vendorId,
roleName: $roleName,
category: $category,
clientRate: $clientRate,
employeeWage: $employeeWage,
markupPercentage: $markupPercentage,
vendorFeePercentage: $vendorFeePercentage,
isActive: $isActive,
notes: $notes,
}
)
}
mutation deleteVendorRate($id: UUID!) @auth(level: USER) {
vendorRate_delete(id: $id)
}

42
apps/web/dataconnect/connector/vendorRate/queries.gql Normal file
View File

@@ -0,0 +1,42 @@
query listVendorRates @auth(level: USER) {
vendorRates {
id
vendorId
roleName
category
clientRate
employeeWage
markupPercentage
vendorFeePercentage
isActive
notes
createdAt
vendor{
companyName
region
}
}
}
query getVendorRateById($id: UUID!) @auth(level: USER) {
vendorRate(id: $id) {
id
vendorId
roleName
category
clientRate
employeeWage
markupPercentage
vendorFeePercentage
isActive
notes
createdAt
vendor{
companyName
region
}
}
}

41
apps/web/dataconnect/connector/workForce/mutations.gql Normal file
View File

@@ -0,0 +1,41 @@
mutation createWorkforce(
$vendorId: UUID!
$staffId: UUID!
$workforceNumber: String!
$employmentType: WorkforceEmploymentType
) @auth(level: USER) {
workforce_insert(
data: {
vendorId: $vendorId
staffId: $staffId
workforceNumber: $workforceNumber
employmentType: $employmentType
status: ACTIVE
}
)
}
mutation updateWorkforce(
$id: UUID!
$workforceNumber: String
$employmentType: WorkforceEmploymentType
$status: WorkforceStatus
) @auth(level: USER) {
workforce_update(
id: $id
data: {
workforceNumber: $workforceNumber
employmentType: $employmentType
status: $status
}
)
}
mutation deactivateWorkforce(
$id: UUID!
) @auth(level: USER) {
workforce_update(
id: $id
data: { status: INACTIVE }
)
}

116
apps/web/dataconnect/connector/workForce/queries.gql Normal file
View File

@@ -0,0 +1,116 @@
# ------------------------------------------------------------
# GET Workforce by ID
# ------------------------------------------------------------
query getWorkforceById($id: UUID!) @auth(level: USER) {
workforce(id: $id) {
id
vendorId
staffId
workforceNumber
employmentType
status
createdAt
updatedAt
staff { id fullName }
vendor { id companyName }
}
}
# ------------------------------------------------------------
# GET Workforce by Vendor + Staff (was "by key")
# ------------------------------------------------------------
query getWorkforceByVendorAndStaff(
$vendorId: UUID!
$staffId: UUID!
) @auth(level: USER) {
workforces(
where: {
vendorId: { eq: $vendorId }
staffId: { eq: $staffId }
}
limit: 1
) {
id
vendorId
staffId
workforceNumber
employmentType
status
createdAt
updatedAt
staff { id fullName }
vendor { id companyName }
}
}
# ------------------------------------------------------------
# LIST Workforce by Vendor
# ------------------------------------------------------------
query listWorkforceByVendorId(
$vendorId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
workforces(
where: { vendorId: { eq: $vendorId } }
offset: $offset
limit: $limit
) {
id
staffId
workforceNumber
employmentType
status
createdAt
staff { id fullName }
}
}
# ------------------------------------------------------------
# LIST Workforce by Staff
# ------------------------------------------------------------
query listWorkforceByStaffId(
$staffId: UUID!
$offset: Int
$limit: Int
) @auth(level: USER) {
workforces(
where: { staffId: { eq: $staffId } }
offset: $offset
limit: $limit
) {
id
vendorId
workforceNumber
employmentType
status
createdAt
updatedAt
vendor { id companyName }
}
}
# ------------------------------------------------------------
# CHECK workforceNumber uniqueness within a Vendor (optional)
# ------------------------------------------------------------
query getWorkforceByVendorAndNumber(
$vendorId: UUID!
$workforceNumber: String!
) @auth(level: USER) {
workforces(
where: {
vendorId: { eq: $vendorId }
workforceNumber: { eq: $workforceNumber }
}
limit: 1
) {
id
staffId
workforceNumber
status
}
}

32
apps/web/dataconnect/schema/ShiftRole.gql Normal file
View File

@@ -0,0 +1,32 @@
enum BreakDuration {
MIN_15
MIN_30
NO_BREAK
}
#this is position, timesheet and schedule in staff app
type ShiftRole @table(name: "shift_roles", key: ["shiftId", "roleId"]) {
id: UUID! @default(expr: "uuidV4()")
shiftId: UUID!
shift: Shift! @ref(fields: "shiftId", references: "id")
roleId: UUID!
role: Role! @ref(fields: "roleId", references: "id")
# demand / requirements
count: Int!
assigned: Int @default(expr: "0")
startTime: Timestamp
endTime: Timestamp
hours: Float
department: String
uniform: String
breakType: BreakDuration
totalValue: Float
createdAt: Timestamp @default(expr: "request.time")
updatedAt: Timestamp @default(expr: "request.time")
}

17
apps/web/dataconnect/schema/VendorBenefitPlan.gql Normal file
View File

@@ -0,0 +1,17 @@
type VendorBenefitPlan @table(name: "vendor_benefit_plans") {
id: UUID! @default(expr: "uuidV4()")
vendorId: UUID!
vendor: Vendor! @ref(fields: "vendorId", references: "id")
title: String!
description: String
requestLabel: String
total: Int
isActive: Boolean @default(expr: "true")
createdAt: Timestamp @default(expr: "request.time")
updatedAt: Timestamp @default(expr: "request.time")
createdBy: String
}

20
apps/web/dataconnect/schema/account.gql Normal file
View File

@@ -0,0 +1,20 @@
enum AccountType {
CHECKING
SAVINGS
}
type Account @table(name: "accounts") {
id: UUID! @default(expr: "uuidV4()")
bank: String!
type: AccountType!
last4: String!
isPrimary: Boolean
accountNumber: String
routeNumber: String
ownerId: UUID! #staff/business
expiryTime: Timestamp
createdAt: Timestamp @default(expr: "request.time")
updatedAt: Timestamp @default(expr: "request.time")
createdBy: String
}

39
apps/web/dataconnect/schema/activityLog.gql Normal file
View File

@@ -0,0 +1,39 @@
enum ActivityIconType {
INVOICE
CHECK
ALERT
MESSAGE
CALENDAR
}
enum ActivityType {
ORDER_CREATED
SHIFT_UPDATE
COMPLIANCE_ALERT
MESSAGE_RECEIVED
SYSTEM_UPDATE
}
type ActivityLog @table(name: "activity_logs") {
id: UUID! @default(expr: "uuidV4()")
userId: String!
#app
date: Timestamp!
hourStart: String
hourEnd: String
totalhours: String
iconType: ActivityIconType
iconColor: String
#web
title: String!
description: String!
isRead: Boolean @default(expr: "false")
activityType: ActivityType!
createdAt: Timestamp @default(expr: "request.time")
updatedAt: Timestamp @default(expr: "request.time")
createdBy: String
}

Some files were not shown because too many files have changed in this diff Show More