@omersx/bemms 0.0.0-stage → 0.1.0

package/src/lib/constants/manufacturers.ts

@@ -0,0 +1,32 @@
+export interface DefaultManufacturerTemplate {
+  name: string;
+  code: string;
+  country: string;
+  website?: string;
+}
+
+export const DEFAULT_MANUFACTURERS: DefaultManufacturerTemplate[] = [
+  { name: 'B. Braun', code: 'BBRAUN', country: 'Germany', website: 'https://www.bbraun.com' },
+  { name: 'Baxter International', code: 'BAXTER', country: 'United States', website: 'https://www.baxter.com' },
+  { name: 'Beckman Coulter', code: 'BECKMAN', country: 'United States', website: 'https://www.beckmancoulter.com' },
+  { name: 'Canon Medical Systems', code: 'CANON', country: 'Japan', website: 'https://global.medical.canon' },
+  { name: 'Dentsply Sirona', code: 'SIRONA', country: 'United States', website: 'https://www.dentsplysirona.com' },
+  { name: 'Dräger (Draeger)', code: 'DRAEGER', country: 'Germany', website: 'https://www.draeger.com' },
+  { name: 'Fresenius Medical Care', code: 'FRESENIUS', country: 'Germany', website: 'https://www.freseniusmedicalcare.com' },
+  { name: 'Fujifilm Healthcare', code: 'FUJIFILM', country: 'Japan', website: 'https://healthcaresolutions-us.fujifilm.com' },
+  { name: 'GE HealthCare', code: 'GE', country: 'United States', website: 'https://www.gehealthcare.com' },
+  { name: 'Getinge / Maquet', code: 'GETINGE', country: 'Sweden', website: 'https://www.getinge.com' },
+  { name: 'Hamilton Medical', code: 'HAMILTON', country: 'Switzerland', website: 'https://www.hamilton-medical.com' },
+  { name: 'Medtronic', code: 'MEDTRONIC', country: 'United States', website: 'https://www.medtronic.com' },
+  { name: 'Mindray', code: 'MINDRAY', country: 'China', website: 'https://www.mindray.com' },
+  { name: 'Nihon Kohden', code: 'NIHON_KOHDEN', country: 'Japan', website: 'https://www.nihonkohden.com' },
+  { name: 'Olympus', code: 'OLYMPUS', country: 'Japan', website: 'https://www.olympus-global.com' },
+  { name: 'Philips Healthcare', code: 'PHILIPS', country: 'Netherlands', website: 'https://www.philips.com/healthcare' },
+  { name: 'Planmeca', code: 'PLANMECA', country: 'Finland', website: 'https://www.planmeca.com' },
+  { name: 'Roche Diagnostics', code: 'ROCHE', country: 'Switzerland', website: 'https://diagnostics.roche.com' },
+  { name: 'Schiller', code: 'SCHILLER', country: 'Switzerland', website: 'https://www.schiller.ch' },
+  { name: 'Siemens Healthineers', code: 'SIEMENS', country: 'Germany', website: 'https://www.siemens-healthineers.com' },
+  { name: 'Stryker', code: 'STRYKER', country: 'United States', website: 'https://www.stryker.com' },
+  { name: 'Zoll Medical', code: 'ZOLL', country: 'United States', website: 'https://www.zoll.com' },
+];
+

package/src/lib/db/index.ts

@@ -0,0 +1,23 @@
+import { Pool } from 'pg';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import * as schema from './schema';
+import { getLogger } from '@/lib/logger';
+
+const log = getLogger('db');
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+  max: parseInt(process.env.DB_POOL_MAX || '20', 10),
+  idleTimeoutMillis: 30000,
+  connectionTimeoutMillis: 5000,
+  ...(process.env.NODE_ENV === 'production' && process.env.DB_SSL !== 'false'
+    ? { ssl: { rejectUnauthorized: false } }
+    : {}),
+});
+
+// Handle unexpected pool errors to prevent crashes
+pool.on('error', (err) => {
+  log.error('Unexpected database pool error', err);
+});
+
+export const db = drizzle(pool, { schema });

package/src/lib/db/schema/audit-logs.ts

@@ -0,0 +1,42 @@
+import { pgTable, bigserial, text, timestamp, jsonb, uuid, index } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import { auditActionTypeEnum } from './enums';
+import { users } from './users';
+import { organizations } from './organizations';
+import { hospitals } from './hospitals';
+
+export const auditLogs = pgTable('audit_logs', {
+  id: bigserial('id', { mode: 'bigint' }).primaryKey(),
+  timestamp: timestamp('timestamp', { withTimezone: true }).defaultNow().notNull(),
+  actorUserId: uuid('actor_user_id'),
+  organizationId: uuid('organization_id'),
+  hospitalId: uuid('hospital_id'),
+  entityType: text('entity_type').notNull(),
+  entityId: text('entity_id').notNull(),
+  actionType: auditActionTypeEnum('action_type').notNull(),
+  previousState: jsonb('previous_state'),
+  newState: jsonb('new_state'),
+  changeReason: text('change_reason'),
+  ipAddress: text('ip_address'),
+  sessionId: text('session_id'),
+}, (t) => ({
+  orgTimeIdx: index('audit_org_time_idx').on(t.organizationId, t.timestamp),
+  entityIdx: index('audit_entity_idx').on(t.entityType, t.entityId),
+  actorTimeIdx: index('audit_actor_time_idx').on(t.actorUserId, t.timestamp),
+}));
+
+export const auditLogsRelations = relations(auditLogs, ({ one }) => ({
+  actorUser: one(users, {
+    fields: [auditLogs.actorUserId],
+    references: [users.id],
+  }),
+  organization: one(organizations, {
+    fields: [auditLogs.organizationId],
+    references: [organizations.id],
+  }),
+  hospital: one(hospitals, {
+    fields: [auditLogs.hospitalId],
+    references: [hospitals.id],
+  }),
+}));
+

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

@@ -0,0 +1,39 @@
+import { pgTable, uuid, text, timestamp, uniqueIndex } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import { departmentStatusEnum } from './enums';
+import { organizations } from './organizations';
+import { hospitals } from './hospitals';
+import { users } from './users';
+
+export const departments = pgTable('departments', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  organizationId: uuid('organization_id').notNull().references(() => organizations.id),
+  hospitalId: uuid('hospital_id').notNull().references(() => hospitals.id),
+  name: text('name').notNull(),
+  code: text('code').notNull(),
+  departmentType: text('department_type'),
+  managerUserId: uuid('manager_user_id'), // fk relations handled below
+  status: departmentStatusEnum('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) => ({
+  hospitalCodeIdx: uniqueIndex('department_hospital_code_idx').on(t.hospitalId, t.code),
+}));
+
+export const departmentsRelations = relations(departments, ({ one }) => ({
+  organization: one(organizations, {
+    fields: [departments.organizationId],
+    references: [organizations.id],
+  }),
+  hospital: one(hospitals, {
+    fields: [departments.hospitalId],
+    references: [hospitals.id],
+  }),
+  manager: one(users, {
+    fields: [departments.managerUserId],
+    references: [users.id],
+  }),
+}));
+

package/src/lib/db/schema/device-categories.ts

@@ -0,0 +1,38 @@
+import { pgTable, uuid, text, integer, timestamp, index } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import { riskClassificationEnum, criticalityLevelEnum, refDataStatusEnum } from './enums';
+import { organizations } from './organizations';
+import { users } from './users';
+
+export const deviceCategories = pgTable('device_categories', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  organizationId: uuid('organization_id').notNull().references(() => organizations.id),
+  name: text('name').notNull(),
+  code: text('code').notNull(),
+  description: text('description'),
+  riskClassification: riskClassificationEnum('risk_classification'),
+  criticalityLevel: criticalityLevelEnum('criticality_level'),
+  defaultPmIntervalDays: integer('default_pm_interval_days'),
+  status: refDataStatusEnum('status').default('active'),
+  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),
+  archivedAt: timestamp('archived_at', { withTimezone: true }),
+  archivedByUserId: uuid('archived_by_user_id').references(() => users.id),
+}, (t) => ({
+  orgCodeIdx: index('device_cat_org_code_idx').on(t.organizationId, t.code),
+}));
+
+export const deviceCategoriesRelations = relations(deviceCategories, ({ one }) => ({
+  organization: one(organizations, {
+    fields: [deviceCategories.organizationId],
+    references: [organizations.id],
+  }),
+  createdByUser: one(users, {
+    fields: [deviceCategories.createdByUserId],
+    references: [users.id],
+    relationName: 'categoriesCreatedByUser',
+  }),
+}));
+

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

@@ -0,0 +1,195 @@
+import { pgTable, uuid, text, timestamp, date, numeric, integer, jsonb, index } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import {
+  deviceStatusCodeEnum, deviceLifecycleStatusEnum,
+  criticalityLevelEnum, riskClassificationEnum,
+  qrLabelStatusEnum, deviceDocumentCategoryEnum,
+  documentVisibilityEnum, transferReasonEnum,
+} from './enums';
+import { organizations } from './organizations';
+import { hospitals } from './hospitals';
+import { departments } from './departments';
+import { locations } from './locations';
+import { users } from './users';
+import { deviceCategories } from './device-categories';
+import { manufacturers, deviceModels } from './manufacturers';
+
+// ── Core Devices Table ──────────────────────────────────────────────────────────
+
+export const devices = pgTable('devices', {
+  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),
+  locationId: uuid('location_id').references(() => locations.id),
+  exactLocationDescription: text('exact_location_description'),
+
+  internalCode: text('internal_code').notNull(),
+  assetNumber: text('asset_number').notNull(),
+  serialNumber: text('serial_number'),
+  name: text('name').notNull(),
+
+  deviceCategoryId: uuid('device_category_id').notNull().references(() => deviceCategories.id),
+  manufacturerId: uuid('manufacturer_id').references(() => manufacturers.id),
+  deviceModelId: uuid('device_model_id').references(() => deviceModels.id),
+  modelNameFree: text('model_name_free'),
+
+  criticalityLevel: criticalityLevelEnum('criticality_level').default('medium'),
+  riskClassification: riskClassificationEnum('risk_classification'),
+
+  currentStatusCode: deviceStatusCodeEnum('current_status_code').default('operational').notNull(),
+  statusChangedAt: timestamp('status_changed_at', { withTimezone: true }),
+  statusChangedByUserId: uuid('status_changed_by_user_id').references(() => users.id),
+  statusLimitationsNote: text('status_limitations_note'),
+
+  purchaseDate: date('purchase_date'),
+  purchaseCost: numeric('purchase_cost', { precision: 12, scale: 2 }),
+  currency: text('currency').default('USD'),
+  installationDate: date('installation_date'),
+  commissioningDate: date('commissioning_date'),
+  warrantyStartDate: date('warranty_start_date'),
+  warrantyEndDate: date('warranty_end_date'),
+
+  technicalSpecifications: jsonb('technical_specifications'),
+
+  assignedEngineerUserId: uuid('assigned_engineer_user_id').references(() => users.id),
+
+  nextPmDueDate: date('next_pm_due_date'),
+  lastMaintenanceCompletedAt: timestamp('last_maintenance_completed_at', { withTimezone: true }),
+  calibrationExpiresOn: date('calibration_expires_on'),
+
+  lifecycleStatus: deviceLifecycleStatusEnum('lifecycle_status').default('active').notNull(),
+  decommissionedAt: timestamp('decommissioned_at', { withTimezone: true }),
+  decommissionedByUserId: uuid('decommissioned_by_user_id').references(() => users.id),
+  decommissionReason: text('decommission_reason'),
+
+  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),
+  archivedAt: timestamp('archived_at', { withTimezone: true }),
+  archivedByUserId: uuid('archived_by_user_id').references(() => users.id),
+  archiveReason: text('archive_reason'),
+}, (t) => ({
+  lookupIdx: index('idx_devices_lookup').on(t.organizationId, t.hospitalId, t.departmentId, t.currentStatusCode),
+  pmDueIdx: index('idx_devices_pm_due').on(t.organizationId, t.nextPmDueDate),
+  internalCodeIdx: index('idx_devices_internal_code').on(t.organizationId, t.internalCode),
+  assetNumberIdx: index('idx_devices_asset_number').on(t.organizationId, t.assetNumber),
+}));
+
+export const devicesRelations = relations(devices, ({ one }) => ({
+  organization: one(organizations, { fields: [devices.organizationId], references: [organizations.id] }),
+  hospital: one(hospitals, { fields: [devices.hospitalId], references: [hospitals.id] }),
+  department: one(departments, { fields: [devices.departmentId], references: [departments.id] }),
+  location: one(locations, { fields: [devices.locationId], references: [locations.id] }),
+  deviceCategory: one(deviceCategories, { fields: [devices.deviceCategoryId], references: [deviceCategories.id] }),
+  manufacturer: one(manufacturers, { fields: [devices.manufacturerId], references: [manufacturers.id] }),
+  deviceModel: one(deviceModels, { fields: [devices.deviceModelId], references: [deviceModels.id] }),
+  assignedEngineer: one(users, { fields: [devices.assignedEngineerUserId], references: [users.id], relationName: 'devicesAssignedToEngineer' }),
+  createdByUser: one(users, { fields: [devices.createdByUserId], references: [users.id], relationName: 'devicesCreatedByUser' }),
+}));
+
+// ── QR Labels ───────────────────────────────────────────────────────────────────
+
+export const deviceQrLabels = pgTable('device_qr_labels', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  organizationId: uuid('organization_id').notNull().references(() => organizations.id),
+  deviceId: uuid('device_id').notNull().references(() => devices.id, { onDelete: 'cascade' }),
+  opaqueReference: text('opaque_reference').notNull().unique(),
+  labelStatus: qrLabelStatusEnum('label_status').default('active').notNull(),
+  printedAt: timestamp('printed_at', { withTimezone: true }),
+  printedByUserId: uuid('printed_by_user_id').references(() => users.id),
+  printCount: integer('print_count').default(0),
+  revokedAt: timestamp('revoked_at', { withTimezone: true }),
+  revokedByUserId: uuid('revoked_by_user_id').references(() => users.id),
+  revocationReason: text('revocation_reason'),
+  replacedByQrId: uuid('replaced_by_qr_id'),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+  createdByUserId: uuid('created_by_user_id').references(() => users.id),
+}, (t) => ({
+  deviceActiveIdx: index('idx_device_qr_active').on(t.deviceId, t.labelStatus),
+}));
+
+export const deviceQrLabelsRelations = relations(deviceQrLabels, ({ one }) => ({
+  device: one(devices, { fields: [deviceQrLabels.deviceId], references: [devices.id] }),
+  organization: one(organizations, { fields: [deviceQrLabels.organizationId], references: [organizations.id] }),
+  printedByUser: one(users, { fields: [deviceQrLabels.printedByUserId], references: [users.id], relationName: 'qrPrintedByUser' }),
+}));
+
+// ── Status History (append-only) ────────────────────────────────────────────────
+
+export const deviceStatusHistory = pgTable('device_status_history', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  organizationId: uuid('organization_id').notNull().references(() => organizations.id),
+  deviceId: uuid('device_id').notNull().references(() => devices.id, { onDelete: 'cascade' }),
+  previousStatusCode: text('previous_status_code'),
+  newStatusCode: text('new_status_code').notNull(),
+  reason: text('reason'),
+  notes: text('notes'),
+  effectiveAt: timestamp('effective_at', { withTimezone: true }).defaultNow().notNull(),
+  changedByUserId: uuid('changed_by_user_id').notNull().references(() => users.id),
+  relatedTicketId: uuid('related_ticket_id'),
+  relatedMaintenanceRecordId: uuid('related_maintenance_record_id'),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+}, (t) => ({
+  deviceTimeIdx: index('idx_device_status_history_device').on(t.deviceId, t.effectiveAt),
+}));
+
+export const deviceStatusHistoryRelations = relations(deviceStatusHistory, ({ one }) => ({
+  device: one(devices, { fields: [deviceStatusHistory.deviceId], references: [devices.id] }),
+  changedByUser: one(users, { fields: [deviceStatusHistory.changedByUserId], references: [users.id], relationName: 'statusChangedByUser' }),
+}));
+
+// ── Location History (append-only) ──────────────────────────────────────────────
+
+export const deviceLocationHistory = pgTable('device_location_history', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  organizationId: uuid('organization_id').notNull().references(() => organizations.id),
+  deviceId: uuid('device_id').notNull().references(() => devices.id, { onDelete: 'cascade' }),
+  previousHospitalId: uuid('previous_hospital_id'),
+  previousDepartmentId: uuid('previous_department_id'),
+  previousLocationId: uuid('previous_location_id'),
+  newHospitalId: uuid('new_hospital_id').notNull(),
+  newDepartmentId: uuid('new_department_id').notNull(),
+  newLocationId: uuid('new_location_id'),
+  transferReason: transferReasonEnum('transfer_reason').notNull(),
+  notes: text('notes'),
+  effectiveAt: timestamp('effective_at', { withTimezone: true }).defaultNow().notNull(),
+  changedByUserId: uuid('changed_by_user_id').notNull().references(() => users.id),
+  relatedTicketId: uuid('related_ticket_id'),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+}, (t) => ({
+  deviceTimeIdx: index('idx_device_location_history_device').on(t.deviceId, t.effectiveAt),
+}));
+
+export const deviceLocationHistoryRelations = relations(deviceLocationHistory, ({ one }) => ({
+  device: one(devices, { fields: [deviceLocationHistory.deviceId], references: [devices.id] }),
+  changedByUser: one(users, { fields: [deviceLocationHistory.changedByUserId], references: [users.id], relationName: 'locationChangedByUser' }),
+  newHospital: one(hospitals, { fields: [deviceLocationHistory.newHospitalId], references: [hospitals.id] }),
+  newDepartment: one(departments, { fields: [deviceLocationHistory.newDepartmentId], references: [departments.id] }),
+}));
+
+// ── Device Attachments ──────────────────────────────────────────────────────────
+
+export const deviceAttachments = pgTable('device_attachments', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  organizationId: uuid('organization_id').notNull().references(() => organizations.id),
+  deviceId: uuid('device_id').notNull().references(() => devices.id, { onDelete: 'cascade' }),
+  documentCategory: deviceDocumentCategoryEnum('document_category').notNull(),
+  fileName: text('file_name').notNull(),
+  fileSize: integer('file_size'),
+  mimeType: text('mime_type'),
+  storageKey: text('storage_key').notNull(),
+  visibility: documentVisibilityEnum('visibility').default('biomedical_only'),
+  uploadedByUserId: uuid('uploaded_by_user_id').references(() => users.id),
+  uploadedAt: timestamp('uploaded_at', { withTimezone: true }).defaultNow().notNull(),
+  archivedAt: timestamp('archived_at', { withTimezone: true }),
+}, (t) => ({
+  deviceIdx: index('idx_device_attachments_device').on(t.deviceId),
+}));
+
+export const deviceAttachmentsRelations = relations(deviceAttachments, ({ one }) => ({
+  device: one(devices, { fields: [deviceAttachments.deviceId], references: [devices.id] }),
+  uploadedByUser: one(users, { fields: [deviceAttachments.uploadedByUserId], references: [users.id], relationName: 'attachmentsUploadedByUser' }),
+}));
+

package/src/lib/db/schema/engineer-profiles.ts

@@ -0,0 +1,63 @@
+import { pgTable, uuid, text, timestamp, jsonb } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import { users } from './users';
+import { organizations } from './organizations';
+import { hospitals } from './hospitals';
+
+export const engineerDutyStatusValues = ['on_duty', 'on_call', 'in_maintenance', 'off_duty'] as const;
+export type EngineerDutyStatus = (typeof engineerDutyStatusValues)[number];
+
+export const engineerProfiles = pgTable('engineer_profiles', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  userId: uuid('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }).unique(),
+  organizationId: uuid('organization_id').references(() => organizations.id),
+  hospitalId: uuid('hospital_id').references(() => hospitals.id),
+  jobTitle: text('job_title').notNull().default('Biomedical Engineer'),
+  specialization: text('specialization').default('General Biomedical Engineering'),
+  extension: text('extension'),
+  mobileNumber: text('mobile_number'),
+  dutyStatus: text('duty_status').$type<EngineerDutyStatus>().default('on_duty').notNull(),
+  shiftHours: text('shift_hours').default('08:00 AM - 04:00 PM'),
+  workingDays: jsonb('working_days').$type<string[]>().default(['Sun', 'Mon', 'Tue', 'Wed', 'Thu']),
+  onCallDays: jsonb('on_call_days').$type<string[]>().default([]),
+  coveredDepartmentIds: jsonb('covered_department_ids').$type<string[]>().default([]),
+  emergencyPriority: text('emergency_priority').default('first_responder'),
+  notes: text('notes'),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+});
+
+export const engineerDutyShifts = pgTable('engineer_duty_shifts', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  engineerProfileId: uuid('engineer_profile_id').notNull().references(() => engineerProfiles.id, { onDelete: 'cascade' }),
+  shiftDate: text('shift_date').notNull(), // 'YYYY-MM-DD'
+  shiftType: text('shift_type').notNull().default('morning'), // 'morning', 'evening', 'night', 'on_call', 'off'
+  startTime: text('start_time'),
+  endTime: text('end_time'),
+  notes: text('notes'),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+});
+
+export const engineerProfilesRelations = relations(engineerProfiles, ({ one, many }) => ({
+  user: one(users, {
+    fields: [engineerProfiles.userId],
+    references: [users.id],
+  }),
+  organization: one(organizations, {
+    fields: [engineerProfiles.organizationId],
+    references: [organizations.id],
+  }),
+  hospital: one(hospitals, {
+    fields: [engineerProfiles.hospitalId],
+    references: [hospitals.id],
+  }),
+  dutyShifts: many(engineerDutyShifts),
+}));
+
+export const engineerDutyShiftsRelations = relations(engineerDutyShifts, ({ one }) => ({
+  engineerProfile: one(engineerProfiles, {
+    fields: [engineerDutyShifts.engineerProfileId],
+    references: [engineerProfiles.id],
+  }),
+}));
+

package/src/lib/db/schema/engineer-rounds.ts

@@ -0,0 +1,115 @@
+import { pgTable, uuid, text, timestamp, integer, jsonb, index, date } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import { roundStatusEnum, roundVisitStatusEnum } from './enums';
+import { organizations } from './organizations';
+import { hospitals } from './hospitals';
+import { departments } from './departments';
+import { users } from './users';
+import { electronicSignatures } from './signatures';
+
+// ── Engineer Rounds ─────────────────────────────────────────────────────────────
+
+export const engineerRounds = pgTable('engineer_rounds', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  organizationId: uuid('organization_id').notNull().references(() => organizations.id),
+  hospitalId: uuid('hospital_id').notNull().references(() => hospitals.id),
+  engineerId: uuid('engineer_id').notNull().references(() => users.id),
+  roundDate: date('round_date').notNull(),
+  shiftType: text('shift_type').notNull().default('morning'), // 'morning', 'evening', 'night'
+  status: roundStatusEnum('status').default('scheduled').notNull(),
+  startedAt: timestamp('started_at', { withTimezone: true }),
+  completedAt: timestamp('completed_at', { withTimezone: true }),
+  startSignatureId: uuid('start_signature_id').references(() => electronicSignatures.id),
+  totalDepartments: integer('total_departments').default(0).notNull(),
+  completedDepartments: integer('completed_departments').default(0).notNull(),
+  totalIssuesReported: integer('total_issues_reported').default(0).notNull(),
+  totalNotes: integer('total_notes').default(0).notNull(),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+}, (t) => ({
+  lookupIdx: index('idx_engineer_rounds_lookup').on(t.organizationId, t.hospitalId, t.engineerId, t.roundDate),
+  dateIdx: index('idx_engineer_rounds_date').on(t.organizationId, t.roundDate, t.status),
+  engineerIdx: index('idx_engineer_rounds_engineer').on(t.engineerId, t.roundDate),
+}));
+
+// ── Round Department Visits ─────────────────────────────────────────────────────
+
+export const roundDepartmentVisits = pgTable('round_department_visits', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  roundId: uuid('round_id').notNull().references(() => engineerRounds.id, { onDelete: 'cascade' }),
+  departmentId: uuid('department_id').notNull().references(() => departments.id),
+  departmentName: text('department_name').notNull(), // Snapshot for historical reference
+  sequence: integer('sequence').notNull().default(0),
+  status: roundVisitStatusEnum('status').default('pending').notNull(),
+  startedAt: timestamp('started_at', { withTimezone: true }),
+  completedAt: timestamp('completed_at', { withTimezone: true }),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+}, (t) => ({
+  roundIdx: index('idx_round_visits_round').on(t.roundId, t.sequence),
+  deptIdx: index('idx_round_visits_dept').on(t.departmentId, t.roundId),
+}));
+
+// ── Round Visit Notes ───────────────────────────────────────────────────────────
+
+export const roundVisitNotes = pgTable('round_visit_notes', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  visitId: uuid('visit_id').notNull().references(() => roundDepartmentVisits.id, { onDelete: 'cascade' }),
+  authorId: uuid('author_id').notNull().references(() => users.id),
+  noteText: text('note_text').notNull(),
+  // Stores parsed @device mentions: [{ deviceId, deviceName, internalCode }]
+  deviceMentions: jsonb('device_mentions').$type<Array<{
+    deviceId: string;
+    deviceName: string;
+    internalCode: string;
+  }>>().default([]),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+}, (t) => ({
+  visitIdx: index('idx_round_notes_visit').on(t.visitId),
+}));
+
+// ── Relations ───────────────────────────────────────────────────────────────────
+
+export const engineerRoundsRelations = relations(engineerRounds, ({ one, many }) => ({
+  organization: one(organizations, {
+    fields: [engineerRounds.organizationId],
+    references: [organizations.id],
+  }),
+  hospital: one(hospitals, {
+    fields: [engineerRounds.hospitalId],
+    references: [hospitals.id],
+  }),
+  engineer: one(users, {
+    fields: [engineerRounds.engineerId],
+    references: [users.id],
+    relationName: 'roundsPerformedByEngineer',
+  }),
+  startSignature: one(electronicSignatures, {
+    fields: [engineerRounds.startSignatureId],
+    references: [electronicSignatures.id],
+  }),
+  departmentVisits: many(roundDepartmentVisits),
+}));
+
+export const roundDepartmentVisitsRelations = relations(roundDepartmentVisits, ({ one, many }) => ({
+  round: one(engineerRounds, {
+    fields: [roundDepartmentVisits.roundId],
+    references: [engineerRounds.id],
+  }),
+  department: one(departments, {
+    fields: [roundDepartmentVisits.departmentId],
+    references: [departments.id],
+  }),
+  notes: many(roundVisitNotes),
+}));
+
+export const roundVisitNotesRelations = relations(roundVisitNotes, ({ one }) => ({
+  visit: one(roundDepartmentVisits, {
+    fields: [roundVisitNotes.visitId],
+    references: [roundDepartmentVisits.id],
+  }),
+  author: one(users, {
+    fields: [roundVisitNotes.authorId],
+    references: [users.id],
+    relationName: 'roundNotesAuthored',
+  }),
+}));