@omersx/bemms 0.0.0-stage → 0.1.0

package/src/lib/db/schema/enums.ts

@@ -0,0 +1,148 @@
+import { pgEnum } from 'drizzle-orm/pg-core';
+
+export const organizationStatusEnum = pgEnum('organization_status', ['active', 'archived']);
+export const hospitalStatusEnum = pgEnum('hospital_status', ['active', 'inactive', 'archived']);
+export const departmentStatusEnum = pgEnum('department_status', ['active', 'inactive', 'archived']);
+export const locationTypeEnum = pgEnum('location_type', ['building', 'floor', 'room', 'area', 'workshop', 'store', 'other']);
+export const locationStatusEnum = pgEnum('location_status', ['active', 'inactive', 'archived']);
+export const userAccountStatusEnum = pgEnum('user_account_status', ['invited', 'active', 'suspended', 'deactivated', 'archived']);
+export const roleStatusEnum = pgEnum('role_status', ['active', 'inactive', 'archived']);
+export const scopeTypeEnum = pgEnum('scope_type', ['organization', 'hospital', 'department', 'location', 'assigned_work', 'category']);
+export const assignmentStatusEnum = pgEnum('assignment_status', ['active', 'revoked', 'expired']);
+export const permissionModuleEnum = pgEnum('permission_module', ['DEVICES', 'TICKETS', 'MAINTENANCE', 'PM_CALIBRATION', 'SIGNATURES', 'REPORTS', 'ADMIN', 'AUDIT']);
+export const permissionActionEnum = pgEnum('permission_action', ['VIEW', 'CREATE', 'EDIT', 'ASSIGN', 'APPROVE', 'SIGN', 'RELEASE', 'ARCHIVE', 'EXPORT', 'MANAGE_POLICY']);
+export const auditActionTypeEnum = pgEnum('audit_action_type', ['CREATE', 'UPDATE', 'DEACTIVATE', 'ARCHIVE', 'TRANSFER', 'PURGE', 'SIGN', 'POLICY_CHANGE', 'LOGIN', 'LOGOUT', 'FAILED_LOGIN']);
+
+// Phase 3: Device Management enums
+export const riskClassificationEnum = pgEnum('risk_classification', ['class_i', 'class_iia', 'class_iib', 'class_iii']);
+export const criticalityLevelEnum = pgEnum('criticality_level', ['critical', 'high', 'medium', 'low']);
+export const deviceStatusCodeEnum = pgEnum('device_status_code', [
+  'operational', 'operational_with_limitations', 'under_maintenance', 'under_repair',
+  'waiting_for_parts', 'awaiting_release', 'out_of_service', 'standby', 'decommissioned'
+]);
+export const deviceLifecycleStatusEnum = pgEnum('device_lifecycle_status', ['active', 'decommissioned', 'archived']);
+export const qrLabelStatusEnum = pgEnum('qr_label_status', ['active', 'replaced', 'revoked']);
+export const deviceDocumentCategoryEnum = pgEnum('device_document_category', [
+  'user_manual', 'service_manual', 'calibration_certificate', 'warranty_doc',
+  'photo', 'inspection_report', 'other'
+]);
+export const documentVisibilityEnum = pgEnum('document_visibility', ['public_department', 'biomedical_only', 'admin_only']);
+export const transferReasonEnum = pgEnum('transfer_reason', [
+  'relocation', 'temporary_loan', 'department_change', 'correction',
+  'replacement', 'workshop', 'storage', 'other'
+]);
+export const refDataStatusEnum = pgEnum('ref_data_status', ['active', 'archived']);
+
+// Phase 4: Helpdesk Tickets enums
+export const ticketStatusCodeEnum = pgEnum('ticket_status_code', [
+  'new', 'acknowledged', 'in_triage', 'in_progress',
+  'waiting_requester', 'waiting_parts_vendor',
+  'resolved', 'closed', 'cancelled'
+]);
+export const ticketPriorityCodeEnum = pgEnum('ticket_priority_code', [
+  'p1_critical', 'p2_high', 'p3_normal', 'p4_low'
+]);
+export const ticketTypeCodeEnum = pgEnum('ticket_type_code', [
+  'device_problem', 'urgent_equipment_concern', 'maintenance_request',
+  'inspection_request', 'calibration_request', 'pm_followup'
+]);
+export const ticketSourceEnum = pgEnum('ticket_source', [
+  'qr_scan', 'department_device_selection', 'device_profile', 'manual_entry', 'import'
+]);
+export const reportedImpactCodeEnum = pgEnum('reported_impact_code', [
+  'device_usable', 'device_not_usable', 'patient_care_affected'
+]);
+export const reporterProblemCategoryCodeEnum = pgEnum('reporter_problem_category_code', [
+  'power_issue', 'device_not_starting', 'display_interface', 'alarm_problem',
+  'sensor_accessory', 'electrical_concern', 'mechanical_damage',
+  'software_configuration', 'performance_concern', 'maintenance_request', 'other'
+]);
+export const maintenanceTypeCodeEnum = pgEnum('maintenance_type_code', [
+  'preventive_maintenance', 'corrective_maintenance', 'troubleshooting',
+  'inspection', 'calibration', 'electrical_safety_testing',
+  'performance_testing', 'installation_commissioning',
+  'software_configuration', 'decommissioning'
+]);
+export const technicalProblemCategoryCodeEnum = pgEnum('technical_problem_category_code', [
+  'electrical_power', 'display_user_interface', 'alarm_safety',
+  'sensor_measurement', 'mechanical', 'software_configuration',
+  'performance_output', 'accessory_consumable', 'physical_damage',
+  'communication_network', 'no_fault_found', 'other'
+]);
+export const ticketCommentVisibilityEnum = pgEnum('ticket_comment_visibility', [
+  'public', 'internal', 'restricted'
+]);
+export const ticketEventTypeEnum = pgEnum('ticket_event_type', [
+  'created', 'acknowledged', 'triaged', 'assigned', 'reassigned',
+  'accepted', 'status_changed', 'priority_changed', 'waiting_for_info',
+  'info_received', 'maintenance_task_linked', 'resolved', 'closed',
+  'cancelled', 'reopened'
+]);
+
+// Phase 5: Maintenance enums
+export const maintenanceTaskStatusCodeEnum = pgEnum('maintenance_task_status_code', [
+  'draft', 'assigned', 'in_progress', 'waiting_dependency',
+  'work_complete', 'awaiting_review', 'returned_for_rework',
+  'awaiting_release', 'closed', 'cancelled'
+]);
+export const maintenancePlanStatusEnum = pgEnum('maintenance_plan_status', [
+  'active', 'paused', 'archived'
+]);
+export const pmCalculationMethodEnum = pgEnum('pm_calculation_method', [
+  'fixed_calendar', 'completion_based'
+]);
+export const occurrenceDueStateEnum = pgEnum('occurrence_due_state', [
+  'scheduled', 'due_soon', 'due_today', 'overdue', 'completed', 'deferred', 'cancelled'
+]);
+export const checklistResultCodeEnum = pgEnum('checklist_result_code', [
+  'passed', 'failed', 'not_applicable', 'requires_follow_up'
+]);
+export const maintenanceFinalResultCodeEnum = pgEnum('maintenance_final_result_code', [
+  'passed', 'passed_with_limitations', 'failed', 'no_fault_found',
+  'decommission_recommended', 'requires_external_service'
+]);
+export const signaturePurposeEnum = pgEnum('signature_purpose', [
+  'accept', 'perform', 'review', 'approve', 'release',
+  'resolve', 'close', 'reject', 'amend', 'void'
+]);
+export const signatureAuthMethodEnum = pgEnum('signature_auth_method', [
+  'password_reauth', 'signing_pin', 'passkey', 'session_challenge'
+]);
+export const signatureStatusEnum = pgEnum('signature_status', [
+  'active', 'superseded', 'rejected', 'voided'
+]);
+export const costTypeEnum = pgEnum('cost_type', [
+  'part', 'vendor_service', 'labor', 'transport', 'other'
+]);
+export const recordVersionEntityTypeEnum = pgEnum('record_version_entity_type', [
+  'maintenance_record', 'device_status_change', 'calibration_record',
+  'test_record', 'ticket_resolution', 'engineer_round'
+]);
+
+// Phase 7: Notification enums
+export const notificationTypeEnum = pgEnum('notification_type', [
+  'ticket_created', 'ticket_accepted',
+  'ticket_assigned', 'ticket_updated', 'ticket_comment',
+  'pm_due_soon', 'pm_overdue', 'calibration_due',
+  'task_review_required', 'task_approved', 'task_rejected',
+  'device_status_changed', 'sla_warning', 'system_alert'
+]);
+
+// Phase 9: Electronic Signatures – Events & Policies
+export const signatureEventTypeEnum = pgEnum('signature_event_type', [
+  'created', 'reviewed', 'approved', 'rejected',
+  'amended', 'superseded', 'voided'
+]);
+export const signaturePolicyActionEnum = pgEnum('signature_policy_action', [
+  'complete_corrective', 'complete_pm', 'complete_calibration',
+  'complete_testing', 'release_device', 'change_device_status',
+  'resolve_ticket', 'close_ticket', 'approve_exception'
+]);
+
+// Phase 13: Engineer's Round enums
+export const roundStatusEnum = pgEnum('round_status', [
+  'scheduled', 'in_progress', 'completed', 'missed', 'cancelled'
+]);
+export const roundVisitStatusEnum = pgEnum('round_visit_status', [
+  'pending', 'completed', 'skipped'
+]);

package/src/lib/db/schema/hospitals.ts

@@ -0,0 +1,34 @@
+import { pgTable, uuid, text, timestamp, uniqueIndex } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import { hospitalStatusEnum } from './enums';
+import { organizations } from './organizations';
+import { departments } from './departments';
+
+export const hospitals = pgTable('hospitals', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  organizationId: uuid('organization_id').notNull().references(() => organizations.id),
+  name: text('name').notNull(),
+  code: text('code').notNull(),
+  address: text('address'),
+  city: text('city'),
+  country: text('country'),
+  phone: text('phone'),
+  email: text('email'),
+  timezone: text('timezone'),
+  status: hospitalStatusEnum('status').default('active'),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+  createdByUserId: uuid('created_by_user_id'),
+  updatedByUserId: uuid('updated_by_user_id'),
+}, (t) => ({
+  orgCodeIdx: uniqueIndex('hospital_org_code_idx').on(t.organizationId, t.code),
+}));
+
+export const hospitalsRelations = relations(hospitals, ({ one, many }) => ({
+  organization: one(organizations, {
+    fields: [hospitals.organizationId],
+    references: [organizations.id],
+  }),
+  departments: many(departments),
+}));
+

package/src/lib/db/schema/index.ts

@@ -0,0 +1,24 @@
+export * from './enums';
+export * from './organizations';
+export * from './hospitals';
+export * from './departments';
+export * from './locations';
+export * from './users';
+export * from './roles';
+export * from './user-assignments';
+export * from './sessions';
+export * from './audit-logs';
+export * from './device-categories';
+export * from './manufacturers';
+export * from './devices';
+export * from './engineer-rounds';
+export * from './tickets';
+export * from './maintenance-plans';
+export * from './maintenance-tasks';
+export * from './maintenance-records';
+export * from './signatures';
+export * from './signature-events';
+export * from './signature-policies';
+export * from './report-history';
+export * from './notifications';
+export * from './engineer-profiles';

package/src/lib/db/schema/locations.ts

@@ -0,0 +1,46 @@
+import { pgTable, uuid, text, timestamp, AnyPgColumn } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import { locationTypeEnum, locationStatusEnum } from './enums';
+import { organizations } from './organizations';
+import { hospitals } from './hospitals';
+import { departments } from './departments';
+
+export const locations = pgTable('locations', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  organizationId: uuid('organization_id').notNull().references(() => organizations.id),
+  hospitalId: uuid('hospital_id').notNull().references(() => hospitals.id),
+  departmentId: uuid('department_id').notNull().references(() => departments.id),
+  parentLocationId: uuid('parent_location_id').references((): AnyPgColumn => locations.id),
+  locationType: locationTypeEnum('location_type').notNull(),
+  name: text('name').notNull(),
+  code: text('code'),
+  status: locationStatusEnum('status').default('active'),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+  createdByUserId: uuid('created_by_user_id'),
+  updatedByUserId: uuid('updated_by_user_id'),
+});
+
+export const locationsRelations = relations(locations, ({ one, many }) => ({
+  organization: one(organizations, {
+    fields: [locations.organizationId],
+    references: [organizations.id],
+  }),
+  hospital: one(hospitals, {
+    fields: [locations.hospitalId],
+    references: [hospitals.id],
+  }),
+  department: one(departments, {
+    fields: [locations.departmentId],
+    references: [departments.id],
+  }),
+  parentLocation: one(locations, {
+    fields: [locations.parentLocationId],
+    references: [locations.id],
+    relationName: 'parentChildLocations',
+  }),
+  childLocations: many(locations, {
+    relationName: 'parentChildLocations',
+  }),
+}));
+

package/src/lib/db/schema/maintenance-plans.ts

@@ -0,0 +1,99 @@
+import { pgTable, uuid, text, timestamp, integer, jsonb, index } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import {
+  maintenanceTypeCodeEnum,
+  pmCalculationMethodEnum,
+  maintenancePlanStatusEnum,
+  occurrenceDueStateEnum,
+} from './enums';
+import { organizations } from './organizations';
+import { hospitals } from './hospitals';
+import { departments } from './departments';
+import { devices } from './devices';
+import { users } from './users';
+
+// ── Maintenance Plans ──────────────────────────────────────────────────────────
+
+export const maintenancePlans = pgTable('maintenance_plans', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  organizationId: uuid('organization_id').notNull().references(() => organizations.id),
+  hospitalId: uuid('hospital_id').notNull().references(() => hospitals.id),
+  departmentId: uuid('department_id').references(() => departments.id),
+  deviceId: uuid('device_id').notNull().references(() => devices.id),
+
+  planTypeCode: maintenanceTypeCodeEnum('plan_type_code').default('preventive_maintenance'),
+  title: text('title'),
+  checklistTemplateVersionId: uuid('checklist_template_version_id'),
+  calculationMethod: pmCalculationMethodEnum('calculation_method').default('fixed_calendar').notNull(),
+  frequencyInterval: integer('frequency_interval').notNull(),
+  frequencyUnit: text('frequency_unit').notNull(),
+
+  startBaselineDate: timestamp('start_baseline_date', { withTimezone: true }).notNull(),
+  nextDueDate: timestamp('next_due_date', { withTimezone: true }).notNull(),
+  leadTimeDays: integer('lead_time_days').default(30),
+  lastQualifyingRecordId: uuid('last_qualifying_record_id'),
+
+  assignedEngineerUserId: uuid('assigned_engineer_user_id').references(() => users.id),
+  assignedTeamId: uuid('assigned_team_id'),
+
+  status: maintenancePlanStatusEnum('status').default('active').notNull(),
+  pauseReason: text('pause_reason'),
+  archiveReason: text('archive_reason'),
+  deviceSnapshot: jsonb('device_snapshot'),
+  instructions: text('instructions'),
+
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+  createdByUserId: uuid('created_by_user_id').references(() => users.id),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+  updatedByUserId: uuid('updated_by_user_id').references(() => users.id),
+}, (t) => ({
+  lookupIdx: index('idx_maintenance_plans_lookup').on(t.organizationId, t.hospitalId, t.departmentId, t.status),
+  deviceIdx: index('idx_maintenance_plans_device').on(t.deviceId, t.status),
+  dueIdx: index('idx_maintenance_plans_due').on(t.organizationId, t.nextDueDate),
+  assigneeIdx: index('idx_maintenance_plans_assignee').on(t.assignedEngineerUserId, t.status),
+}));
+
+export const maintenancePlansRelations = relations(maintenancePlans, ({ one, many }) => ({
+  organization: one(organizations, { fields: [maintenancePlans.organizationId], references: [organizations.id] }),
+  hospital: one(hospitals, { fields: [maintenancePlans.hospitalId], references: [hospitals.id] }),
+  department: one(departments, { fields: [maintenancePlans.departmentId], references: [departments.id] }),
+  device: one(devices, { fields: [maintenancePlans.deviceId], references: [devices.id] }),
+  assignedEngineer: one(users, { fields: [maintenancePlans.assignedEngineerUserId], references: [users.id], relationName: 'maintenancePlansAssignedEngineer' }),
+  createdByUser: one(users, { fields: [maintenancePlans.createdByUserId], references: [users.id], relationName: 'maintenancePlansCreatedByUser' }),
+  updatedByUser: one(users, { fields: [maintenancePlans.updatedByUserId], references: [users.id], relationName: 'maintenancePlansUpdatedByUser' }),
+  occurrences: many(maintenanceScheduleOccurrences),
+}));
+
+// ── Maintenance Schedule Occurrences ──────────────────────────────────────────
+
+export const maintenanceScheduleOccurrences = pgTable('maintenance_schedule_occurrences', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  maintenancePlanId: uuid('maintenance_plan_id').notNull().references(() => maintenancePlans.id, { onDelete: 'cascade' }),
+  deviceId: uuid('device_id').notNull().references(() => devices.id),
+
+  originalDueDate: timestamp('original_due_date', { withTimezone: true }).notNull(),
+  currentDueDate: timestamp('current_due_date', { withTimezone: true }).notNull(),
+  dueState: occurrenceDueStateEnum('due_state').default('scheduled').notNull(),
+
+  generatedTaskId: uuid('generated_task_id'),
+  generatedAt: timestamp('generated_at', { withTimezone: true }),
+  qualifyingRecordId: uuid('qualifying_record_id'),
+
+  deferredAt: timestamp('deferred_at', { withTimezone: true }),
+  deferralReason: text('deferral_reason'),
+  deferredByUserId: uuid('deferred_by_user_id').references(() => users.id),
+
+  cancelledAt: timestamp('cancelled_at', { withTimezone: true }),
+  cancellationReason: text('cancellation_reason'),
+}, (t) => ({
+  planIdx: index('idx_maintenance_occurrences_plan').on(t.maintenancePlanId, t.dueState),
+  deviceIdx: index('idx_maintenance_occurrences_device').on(t.deviceId, t.dueState),
+  dueDateIdx: index('idx_maintenance_occurrences_due').on(t.currentDueDate, t.dueState),
+}));
+
+export const maintenanceScheduleOccurrencesRelations = relations(maintenanceScheduleOccurrences, ({ one }) => ({
+  maintenancePlan: one(maintenancePlans, { fields: [maintenanceScheduleOccurrences.maintenancePlanId], references: [maintenancePlans.id] }),
+  device: one(devices, { fields: [maintenanceScheduleOccurrences.deviceId], references: [devices.id] }),
+  deferredByUser: one(users, { fields: [maintenanceScheduleOccurrences.deferredByUserId], references: [users.id], relationName: 'occurrencesDeferredByUser' }),
+}));
+

package/src/lib/db/schema/maintenance-records.ts

@@ -0,0 +1,161 @@
+import { pgTable, uuid, text, timestamp, integer, boolean, AnyPgColumn, index } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import {
+  maintenanceTypeCodeEnum,
+  technicalProblemCategoryCodeEnum,
+  maintenanceFinalResultCodeEnum,
+  deviceStatusCodeEnum,
+  costTypeEnum,
+} from './enums';
+import { organizations } from './organizations';
+import { devices } from './devices';
+import { maintenanceTasks } from './maintenance-tasks';
+import { serviceTickets } from './tickets';
+import { users } from './users';
+
+// ── Maintenance Records ───────────────────────────────────────────────────────
+
+export const maintenanceRecords = pgTable('maintenance_records', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  recordNumber: text('record_number').notNull().unique(),
+  organizationId: uuid('organization_id').notNull().references(() => organizations.id),
+  deviceId: uuid('device_id').notNull().references(() => devices.id),
+  maintenanceTaskId: uuid('maintenance_task_id').notNull().references(() => maintenanceTasks.id),
+  serviceTicketId: uuid('service_ticket_id').references(() => serviceTickets.id),
+  maintenanceType: maintenanceTypeCodeEnum('maintenance_type').notNull(),
+  technicalCategory: technicalProblemCategoryCodeEnum('technical_category'),
+  diagnosis: text('diagnosis'),
+  rootCause: text('root_cause'),
+  workPerformed: text('work_performed'),
+  findings: text('findings'),
+  recommendations: text('recommendations'),
+  finalResultCode: maintenanceFinalResultCodeEnum('final_result_code').notNull(),
+  finalDeviceStatusCode: deviceStatusCodeEnum('final_device_status_code').notNull(),
+  calibrationCertificateNumber: text('calibration_certificate_number'),
+  calibrationValidUntil: timestamp('calibration_valid_until', { withTimezone: true }),
+  nextMaintenanceDateProposal: timestamp('next_maintenance_date_proposal', { withTimezone: true }),
+  startedAt: timestamp('started_at', { withTimezone: true }).notNull(),
+  completedAt: timestamp('completed_at', { withTimezone: true }).notNull(),
+  currentVersionNumber: integer('current_version_number').default(1).notNull(),
+  isFinalized: boolean('is_finalized').default(false).notNull(),
+  isAmended: boolean('is_amended').default(false).notNull(),
+  originalRecordId: uuid('original_record_id').references((): AnyPgColumn => maintenanceRecords.id),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+  createdByUserId: uuid('created_by_user_id').references(() => users.id),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+}, (t) => ({
+  deviceIdx: index('idx_maintenance_records_device').on(t.deviceId, t.completedAt),
+  recordNumIdx: index('idx_maintenance_records_number').on(t.organizationId, t.recordNumber),
+  taskIdx: index('idx_maintenance_records_task').on(t.maintenanceTaskId),
+  ticketIdx: index('idx_maintenance_records_ticket').on(t.serviceTicketId),
+  lookupIdx: index('idx_maintenance_records_lookup').on(t.organizationId, t.finalResultCode),
+  calValidIdx: index('idx_maintenance_records_cal_valid').on(t.calibrationValidUntil),
+}));
+
+export const maintenanceRecordsRelations = relations(maintenanceRecords, ({ one, many }) => ({
+  organization: one(organizations, {
+    fields: [maintenanceRecords.organizationId],
+    references: [organizations.id],
+  }),
+  device: one(devices, {
+    fields: [maintenanceRecords.deviceId],
+    references: [devices.id],
+  }),
+  maintenanceTask: one(maintenanceTasks, {
+    fields: [maintenanceRecords.maintenanceTaskId],
+    references: [maintenanceTasks.id],
+  }),
+  serviceTicket: one(serviceTickets, {
+    fields: [maintenanceRecords.serviceTicketId],
+    references: [serviceTickets.id],
+  }),
+  createdByUser: one(users, {
+    fields: [maintenanceRecords.createdByUserId],
+    references: [users.id],
+    relationName: 'maintenanceRecordsCreatedByUser',
+  }),
+  originalRecord: one(maintenanceRecords, {
+    fields: [maintenanceRecords.originalRecordId],
+    references: [maintenanceRecords.id],
+    relationName: 'maintenanceRecordAmendments',
+  }),
+  amendments: many(maintenanceRecords, {
+    relationName: 'maintenanceRecordAmendments',
+  }),
+  parts: many(maintenanceParts),
+  costs: many(maintenanceCosts),
+}));
+
+// ── Maintenance Parts ─────────────────────────────────────────────────────────
+
+export const maintenanceParts = pgTable('maintenance_parts', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  maintenanceTaskId: uuid('maintenance_task_id').notNull().references(() => maintenanceTasks.id),
+  maintenanceRecordId: uuid('maintenance_record_id').references(() => maintenanceRecords.id),
+  partNumber: text('part_number').notNull(),
+  partName: text('part_name').notNull(),
+  quantity: integer('quantity').default(1).notNull(),
+  unitCost: integer('unit_cost'),
+  currency: text('currency').default('USD'),
+  supplierName: text('supplier_name'),
+  notes: text('notes'),
+  recordedByUserId: uuid('recorded_by_user_id').references(() => users.id),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+}, (t) => ({
+  taskIdx: index('idx_maintenance_parts_task').on(t.maintenanceTaskId),
+  recordIdx: index('idx_maintenance_parts_record').on(t.maintenanceRecordId),
+  partNumIdx: index('idx_maintenance_parts_number').on(t.partNumber),
+}));
+
+export const maintenancePartsRelations = relations(maintenanceParts, ({ one }) => ({
+  maintenanceTask: one(maintenanceTasks, {
+    fields: [maintenanceParts.maintenanceTaskId],
+    references: [maintenanceTasks.id],
+  }),
+  maintenanceRecord: one(maintenanceRecords, {
+    fields: [maintenanceParts.maintenanceRecordId],
+    references: [maintenanceRecords.id],
+  }),
+  recordedByUser: one(users, {
+    fields: [maintenanceParts.recordedByUserId],
+    references: [users.id],
+    relationName: 'maintenancePartsRecordedByUser',
+  }),
+}));
+
+// ── Maintenance Costs ─────────────────────────────────────────────────────────
+
+export const maintenanceCosts = pgTable('maintenance_costs', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  maintenanceTaskId: uuid('maintenance_task_id').notNull().references(() => maintenanceTasks.id),
+  maintenanceRecordId: uuid('maintenance_record_id').references(() => maintenanceRecords.id),
+  costType: costTypeEnum('cost_type').notNull(),
+  amount: integer('amount').notNull(),
+  currency: text('currency').default('USD'),
+  vendorName: text('vendor_name'),
+  invoiceNumber: text('invoice_number'),
+  description: text('description'),
+  recordedByUserId: uuid('recorded_by_user_id').references(() => users.id),
+  recordedAt: timestamp('recorded_at', { withTimezone: true }).defaultNow().notNull(),
+}, (t) => ({
+  taskIdx: index('idx_maintenance_costs_task').on(t.maintenanceTaskId),
+  recordIdx: index('idx_maintenance_costs_record').on(t.maintenanceRecordId),
+  costTypeIdx: index('idx_maintenance_costs_type').on(t.costType),
+}));
+
+export const maintenanceCostsRelations = relations(maintenanceCosts, ({ one }) => ({
+  maintenanceTask: one(maintenanceTasks, {
+    fields: [maintenanceCosts.maintenanceTaskId],
+    references: [maintenanceTasks.id],
+  }),
+  maintenanceRecord: one(maintenanceRecords, {
+    fields: [maintenanceCosts.maintenanceRecordId],
+    references: [maintenanceRecords.id],
+  }),
+  recordedByUser: one(users, {
+    fields: [maintenanceCosts.recordedByUserId],
+    references: [users.id],
+    relationName: 'maintenanceCostsRecordedByUser',
+  }),
+}));
+