@zi2/relay-sdk 1.0.0

package/dist/server/fastify-plugin.d.ts

@@ -0,0 +1,26 @@
+import { h as RelaySDK } from '../types-CPJUrmcy.js';
+import 'ws';
+
+/**
+ * Fastify plugin for ZI2 Relay SDK.
+ * Registers all relay REST routes and WebSocket upgrade handler.
+ *
+ * Requires @fastify/websocket for WebSocket support.
+ *
+ * @example
+ * ```typescript
+ * import Fastify from 'fastify';
+ * import websocket from '@fastify/websocket';
+ * import { relayPlugin } from '@zi2/relay-sdk/fastify';
+ *
+ * const app = Fastify();
+ * await app.register(websocket);
+ * await app.register(relayPlugin, { sdk, prefix: '/phone-relay' });
+ * ```
+ */
+declare function relayPlugin(fastify: any, opts: {
+    sdk: RelaySDK;
+    prefix?: string;
+}): Promise<void>;
+
+export { relayPlugin };

package/dist/server/fastify-plugin.js

@@ -0,0 +1,125 @@
+// src/schemas.ts
+import { z } from "zod";
+var completePairingSchema = z.object({
+  pairingId: z.string().uuid(),
+  pairingToken: z.string().min(1),
+  devicePublicKey: z.string().min(44).max(5e3),
+  deviceName: z.string().min(1).max(200),
+  platform: z.enum(["android", "ios"]),
+  phoneNumber: z.string().max(30).optional()
+});
+var updatePhoneRelaySchema = z.object({
+  deviceName: z.string().min(1).max(200).optional(),
+  maxSmsPerMinute: z.number().int().min(1).max(60).optional(),
+  maxSmsPerHour: z.number().int().min(1).max(1e3).optional(),
+  maxSmsPerDay: z.number().int().min(1).max(1e4).optional()
+});
+var testRelaySmsSchema = z.object({
+  to: z.string().min(1),
+  body: z.string().min(1).max(160).optional()
+});
+var relayMessagesQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).default(50),
+  offset: z.coerce.number().int().min(0).default(0)
+});
+
+// src/server/routes.ts
+function createRouteHandlers(sdk) {
+  return {
+    async initiatePairing(orgId, userId) {
+      const result = await sdk.initiatePairing(orgId, userId);
+      return result;
+    },
+    async completePairing(body) {
+      const parsed = completePairingSchema.parse(body);
+      const result = await sdk.completePairing(
+        parsed.pairingId,
+        parsed.pairingToken,
+        parsed.devicePublicKey,
+        parsed.deviceName,
+        parsed.platform,
+        parsed.phoneNumber
+      );
+      return result;
+    },
+    async listRelays(orgId) {
+      const relays = await sdk.listRelays(orgId);
+      return relays;
+    },
+    async getRelay(id, orgId) {
+      const relay = await sdk.getRelay(id, orgId);
+      return relay;
+    },
+    async updateRelay(id, orgId, body) {
+      const parsed = updatePhoneRelaySchema.parse(body);
+      const relay = await sdk.updateRelay(id, orgId, parsed);
+      return relay;
+    },
+    async revokeRelay(id, orgId) {
+      await sdk.revokeRelay(id, orgId);
+    },
+    async testSms(id, orgId, body) {
+      const parsed = testRelaySmsSchema.parse(body);
+      const testBody = parsed.body || "ZI2 Relay test message";
+      const result = await sdk.sendSMS(id, orgId, parsed.to, testBody);
+      return result;
+    },
+    async getMessages(id, orgId, query) {
+      const parsed = relayMessagesQuerySchema.parse(query);
+      const result = await sdk.getMessages(id, orgId, parsed.limit, parsed.offset);
+      return result;
+    }
+  };
+}
+
+// src/server/fastify-plugin.ts
+async function relayPlugin(fastify, opts) {
+  const handlers = createRouteHandlers(opts.sdk);
+  const prefix = opts.prefix || "";
+  fastify.post(`${prefix}/pair/initiate`, async (request, reply) => {
+    const result = await handlers.initiatePairing(request.orgId, request.userId);
+    reply.send({ success: true, data: result });
+  });
+  fastify.post(`${prefix}/pair/complete`, async (request, reply) => {
+    const result = await handlers.completePairing(request.body);
+    reply.send({ success: true, data: result });
+  });
+  fastify.get(`${prefix}/`, async (request, reply) => {
+    const relays = await handlers.listRelays(request.orgId);
+    reply.send({ success: true, data: relays });
+  });
+  fastify.get(`${prefix}/:id`, async (request, reply) => {
+    const { id } = request.params;
+    const relay = await handlers.getRelay(id, request.orgId);
+    reply.send({ success: true, data: relay });
+  });
+  fastify.patch(`${prefix}/:id`, async (request, reply) => {
+    const { id } = request.params;
+    await handlers.updateRelay(id, request.orgId, request.body);
+    reply.send({ success: true });
+  });
+  fastify.delete(`${prefix}/:id`, async (request, reply) => {
+    const { id } = request.params;
+    await handlers.revokeRelay(id, request.orgId);
+    reply.send({ success: true });
+  });
+  fastify.post(`${prefix}/:id/test`, async (request, reply) => {
+    const { id } = request.params;
+    const result = await handlers.testSms(id, request.orgId, request.body);
+    reply.send({ success: true, data: result });
+  });
+  fastify.get(`${prefix}/:id/messages`, async (request, reply) => {
+    const { id } = request.params;
+    const result = await handlers.getMessages(id, request.orgId, request.query);
+    reply.send({ success: true, data: result });
+  });
+  fastify.get("/ws/relay", { websocket: true }, (socket, req) => {
+    opts.sdk.handleWebSocket(socket, {
+      ip: req.ip || req.socket?.remoteAddress || "unknown",
+      log: req.log
+    });
+  });
+}
+export {
+  relayPlugin
+};

package/dist/types-CPJUrmcy.d.ts

@@ -0,0 +1,288 @@
+import { WebSocket } from 'ws';
+
+interface PhoneRelayRecord {
+    id: string;
+    organizationId: string;
+    deviceName: string;
+    platform: string;
+    phoneNumber: string | null;
+    devicePublicKey: string;
+    sharedKeyEncrypted: string;
+    authTokenHash: string;
+    status: string;
+    keyVersion: number;
+    lastKeyRotation: Date;
+    lastSeenAt: Date | null;
+    lastIpAddress: string | null;
+    batteryLevel: number | null;
+    signalStrength: number | null;
+    totalSmsSent: number;
+    totalSmsFailed: number;
+    dailySmsSent: number;
+    dailyResetAt: Date;
+    maxSmsPerMinute: number;
+    maxSmsPerHour: number;
+    maxSmsPerDay: number;
+    pairedById: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface PhoneRelayPairingRecord {
+    id: string;
+    organizationId: string;
+    pairingToken: string;
+    serverPublicKey: string;
+    serverPrivateKeyEncrypted: string;
+    status: string;
+    initiatedById: string;
+    expiresAt: Date;
+    createdAt: Date;
+}
+interface RelayMessageRecord {
+    id: string;
+    relayId: string;
+    organizationId: string;
+    encryptedPayload: string;
+    status: string;
+    attempts: number;
+    maxAttempts: number;
+    nativeMessageId: string | null;
+    errorMessage: string | null;
+    deliveryStatus: string | null;
+    sentToDeviceAt: Date | null;
+    ackedAt: Date | null;
+    expiresAt: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+type CreateRelayInput = Omit<PhoneRelayRecord, 'id' | 'createdAt' | 'updatedAt' | 'keyVersion' | 'totalSmsSent' | 'totalSmsFailed' | 'dailySmsSent'>;
+type CreatePairingInput = Omit<PhoneRelayPairingRecord, 'id' | 'createdAt'>;
+type CreateMessageInput = Pick<RelayMessageRecord, 'relayId' | 'organizationId' | 'encryptedPayload' | 'expiresAt'>;
+interface DatabaseAdapter {
+    findRelay(id: string, orgId?: string): Promise<PhoneRelayRecord | null>;
+    findRelayByTokenHash(id: string, tokenHash: string, statuses: string[]): Promise<PhoneRelayRecord | null>;
+    findRelays(orgId: string, excludeStatus?: string): Promise<PhoneRelayRecord[]>;
+    createRelay(data: CreateRelayInput): Promise<PhoneRelayRecord>;
+    updateRelay(id: string, data: Partial<PhoneRelayRecord>): Promise<void>;
+    updateRelayByOrg(id: string, orgId: string, data: Partial<PhoneRelayRecord>): Promise<void>;
+    deleteRelay(id: string): Promise<void>;
+    incrementRelayStat(id: string, field: 'totalSmsSent' | 'totalSmsFailed' | 'dailySmsSent', amount?: number): Promise<void>;
+    countRelays(orgId: string): Promise<number>;
+    markDegradedRelays(threshold: Date): Promise<number>;
+    resetDailyCounters(): Promise<number>;
+    findPairing(id: string): Promise<PhoneRelayPairingRecord | null>;
+    createPairing(data: CreatePairingInput): Promise<PhoneRelayPairingRecord>;
+    updatePairingStatus(id: string, status: string): Promise<void>;
+    deleteExpiredPairings(): Promise<number>;
+    findMessage(id: string): Promise<RelayMessageRecord | null>;
+    createMessage(data: CreateMessageInput): Promise<RelayMessageRecord>;
+    updateMessage(id: string, data: Partial<RelayMessageRecord>): Promise<void>;
+    findPendingMessages(relayId: string, limit: number): Promise<RelayMessageRecord[]>;
+    findMessages(relayId: string, limit: number, offset: number): Promise<{
+        messages: RelayMessageRecord[];
+        total: number;
+    }>;
+    deleteMessagesByRelay(relayId: string): Promise<number>;
+    expireStaleMessages(): Promise<number>;
+    createMessages(batch: CreateMessageInput[]): Promise<RelayMessageRecord[]>;
+    updateMessages(ids: string[], data: Partial<RelayMessageRecord>): Promise<number>;
+}
+interface EncryptionAdapter {
+    encrypt(plaintext: string): string;
+    decrypt(ciphertext: string): string;
+}
+interface BroadcastAdapter {
+    broadcast(orgId: string, message: Record<string, unknown>): void;
+}
+interface LoggerAdapter {
+    debug(msg: string, data?: Record<string, unknown>): void;
+    info(msg: string, data?: Record<string, unknown>): void;
+    warn(msg: string, data?: Record<string, unknown>): void;
+    error(msg: string, data?: Record<string, unknown>): void;
+}
+interface ConnectionBroker {
+    publish(channel: string, message: string): Promise<void>;
+    subscribe(channel: string, handler: (message: string) => void): Promise<void>;
+    unsubscribe(channel: string): Promise<void>;
+}
+/**
+ * Audit trail adapter for PCI DSS v4 Req 10 / SOC 2 CC7.2.
+ * Records all security-relevant actions for compliance logging.
+ */
+interface AuditAdapter {
+    log(entry: AuditEntry): Promise<void>;
+}
+interface AuditEntry {
+    timestamp: Date;
+    action: 'pairing.initiated' | 'pairing.completed' | 'relay.revoked' | 'relay.keys_rotated' | 'sms.sent' | 'sms.failed' | 'sms.delivered' | 'relay.connected' | 'relay.disconnected' | 'relay.auth_failed' | 'relay.rate_limited' | 'relay.updated';
+    organizationId: string;
+    relayId?: string;
+    userId?: string;
+    ip?: string;
+    metadata?: Record<string, unknown>;
+}
+interface SmsSendResponse {
+    messageId?: string;
+    success: boolean;
+}
+interface SmsProviderAdapter {
+    readonly name: string;
+    initialize(credentials: Record<string, string>): void;
+    sendSms(to: string, body: string): Promise<SmsSendResponse>;
+    validateCredentials(credentials: Record<string, string>): Promise<boolean>;
+}
+interface RelaySDKConfig {
+    db: DatabaseAdapter;
+    encryption: EncryptionAdapter;
+    broadcast?: BroadcastAdapter;
+    logger?: LoggerAdapter;
+    /** Audit trail for PCI DSS v4 Req 10 / SOC 2 CC7.2 compliance */
+    audit?: AuditAdapter;
+    apiUrl?: string;
+    wsUrl?: string;
+    /** Enforce TLS-only WebSocket connections (PCI DSS v4 Req 4.2.1). Default: true */
+    enforceTls?: boolean;
+    /** Maximum auth attempts before IP blacklist (PCI DSS v4 Req 8.3.4). Default: 10 */
+    maxAuthFailuresPerIp?: number;
+    /** Called after pairing completes. Use to auto-create SmsProvider records. */
+    onPairingComplete?: (relay: {
+        relayId: string;
+        orgId: string;
+        deviceName: string;
+        phoneNumber?: string;
+    }) => Promise<void>;
+    /** Called after relay is revoked. Use to clean up SmsProvider records. */
+    onRelayRevoked?: (relay: {
+        relayId: string;
+        orgId: string;
+    }) => Promise<void>;
+    /** Override default rate limits. Uses same keys as RELAY_LIMITS constants. */
+    limits?: Partial<{
+        AUTH_TIMEOUT_MS: number;
+        HEARTBEAT_INTERVAL_MS: number;
+        PAIRING_EXPIRY_MINUTES: number;
+        MESSAGE_EXPIRY_HOURS: number;
+        QUEUE_DRAIN_DELAY_MS: number;
+        DEFAULT_SMS_TIMEOUT_MS: number;
+        MAX_SMS_PER_MINUTE: number;
+        MAX_SMS_PER_HOUR: number;
+        MAX_SMS_PER_DAY: number;
+        DEGRADED_THRESHOLD_MS: number;
+    }>;
+}
+interface PairingResult {
+    pairingId: string;
+    serverPublicKey: string;
+    pairingToken: string;
+    wsUrl: string;
+}
+interface PairingCompleteResult {
+    relayId: string;
+    authToken: string;
+}
+interface SendResult {
+    messageId: string;
+    status: string;
+}
+interface RelayListItem {
+    id: string;
+    deviceName: string;
+    platform: string;
+    phoneNumber: string | null;
+    status: string;
+    lastSeenAt: Date | null;
+    batteryLevel: number | null;
+    signalStrength: number | null;
+    totalSmsSent: number;
+    totalSmsFailed: number;
+    dailySmsSent: number;
+    maxSmsPerMinute: number;
+    maxSmsPerHour: number;
+    maxSmsPerDay: number;
+    isOnline: boolean;
+    createdAt: Date;
+}
+interface RelayDetail {
+    id: string;
+    organizationId: string;
+    deviceName: string;
+    platform: string;
+    phoneNumber: string | null;
+    status: string;
+    keyVersion: number;
+    lastKeyRotation: Date;
+    lastSeenAt: Date | null;
+    lastIpAddress: string | null;
+    batteryLevel: number | null;
+    signalStrength: number | null;
+    totalSmsSent: number;
+    totalSmsFailed: number;
+    dailySmsSent: number;
+    dailyResetAt: Date;
+    maxSmsPerMinute: number;
+    maxSmsPerHour: number;
+    maxSmsPerDay: number;
+    pairedById: string;
+    isOnline: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface MessageList {
+    messages: RelayMessageRecord[];
+    pagination: {
+        total: number;
+        limit: number;
+        offset: number;
+    };
+}
+interface FallbackConfig {
+    primary: SmsProviderAdapter;
+    fallbacks: SmsProviderAdapter[];
+    isOnline: () => boolean;
+    onFallback?: (provider: string) => void;
+}
+interface RelaySDK {
+    initiatePairing(orgId: string, userId: string): Promise<PairingResult>;
+    completePairing(input: {
+        pairingId: string;
+        pairingToken: string;
+        devicePublicKey: string;
+        deviceName: string;
+        platform: string;
+        phoneNumber?: string;
+    }): Promise<PairingCompleteResult>;
+    listRelays(orgId: string): Promise<RelayListItem[]>;
+    getRelay(id: string, orgId: string): Promise<RelayDetail | null>;
+    updateRelay(id: string, orgId: string, data: Record<string, unknown>): Promise<void>;
+    revokeRelay(id: string, orgId: string): Promise<void>;
+    rotateKeys(id: string, orgId: string): Promise<void>;
+    sendSMS(options: {
+        relayId: string;
+        orgId: string;
+        to: string;
+        body: string;
+        timeoutMs?: number;
+    }): Promise<SendResult>;
+    getMessages(relayId: string, orgId: string, limit?: number, offset?: number): Promise<MessageList>;
+    isRelayOnline(relayId: string): boolean;
+    getRelaySocket(relayId: string): WebSocket | undefined;
+    handleWebSocket(socket: WebSocket, request: {
+        ip: string;
+        log?: LoggerAdapter;
+    }): void;
+    createProvider(relayId: string, orgId: string): SmsProviderAdapter;
+    createFallbackProvider(config: FallbackConfig): SmsProviderAdapter;
+    onRelayOnline(handler: (relayId: string, orgId: string) => void): () => void;
+    onRelayOffline(handler: (relayId: string, orgId: string) => void): () => void;
+    onMessageDelivered(handler: (messageId: string, relayId: string) => void): () => void;
+    onMessageFailed(handler: (messageId: string, relayId: string, error: string) => void): () => void;
+    runHealthCheck(): Promise<{
+        expiredMessages: number;
+        degradedRelays: number;
+        cleanedPairings: number;
+    }>;
+    startHealthService(): void;
+    stopHealthService(): void;
+}
+
+export type { AuditAdapter as A, BroadcastAdapter as B, ConnectionBroker as C, DatabaseAdapter as D, EncryptionAdapter as E, FallbackConfig as F, LoggerAdapter as L, MessageList as M, PhoneRelayRecord as P, RelayMessageRecord as R, SmsProviderAdapter as S, AuditEntry as a, SmsSendResponse as b, CreateRelayInput as c, PhoneRelayPairingRecord as d, CreatePairingInput as e, CreateMessageInput as f, RelaySDKConfig as g, RelaySDK as h, PairingCompleteResult as i, PairingResult as j, RelayDetail as k, RelayListItem as l, SendResult as m };

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@zi2/relay-sdk",
+  "version": "1.0.0",
+  "description": "Enterprise SMS relay SDK with E2E encryption, provider fallback, and PCI DSS v4 compliance",
+  "author": "Zenith Intelligence Technologies <dev@zisquare.app>",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://zisquare.app/dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nicad-tech/zi2-relay-sdk"
+  },
+  "keywords": ["sms", "relay", "e2e-encryption", "websocket", "pci-dss", "soc2", "twilio-alternative", "sms-gateway"],
+  "type": "module",
+  "files": ["dist/", "prisma/", "README.md", "CHANGELOG.md", "LICENSE"],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./client": {
+      "import": "./dist/client/index.js",
+      "types": "./dist/client/index.d.ts"
+    },
+    "./adapters/prisma": {
+      "import": "./dist/adapters/prisma-adapter.js",
+      "types": "./dist/adapters/prisma-adapter.d.ts"
+    },
+    "./fastify": {
+      "import": "./dist/server/fastify-plugin.js",
+      "types": "./dist/server/fastify-plugin.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist .turbo"
+  },
+  "dependencies": {
+    "zod": "^3.24.0"
+  },
+  "peerDependencies": {
+    "@prisma/client": ">=5.0.0",
+    "fastify": ">=4.0.0",
+    "ws": ">=8.0.0",
+    "ioredis": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@prisma/client": {
+      "optional": true
+    },
+    "fastify": {
+      "optional": true
+    },
+    "ws": {
+      "optional": true
+    },
+    "ioredis": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@capacitor/core": "^8.3.0",
+    "@capacitor/preferences": "^6.0.0",
+    "@types/ws": "^8.5.0",
+    "@zi2/tsconfig": "workspace:*",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  }
+}

package/prisma/schema.prisma

@@ -0,0 +1,89 @@
+// ============================================================================
+// @zi2/relay-sdk — Reference Prisma Schema
+//
+// These are the relay-specific models required by the SDK. Copy them into your
+// own schema.prisma (adjusting the datasource and any relations to your app's
+// models such as Organization). The PrismaAdapter expects these tables to exist.
+// ============================================================================
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+model PhoneRelay {
+  id                 String    @id @default(uuid()) @db.Uuid
+  organizationId     String    @map("organization_id") @db.Uuid
+  deviceName         String    @map("device_name") @db.VarChar(200)
+  platform           String    @db.VarChar(20)
+  phoneNumber        String?   @map("phone_number") @db.VarChar(30)
+  devicePublicKey    String    @map("device_public_key") @db.Text
+  sharedKeyEncrypted String    @map("shared_key_encrypted") @db.Text
+  authTokenHash      String    @map("auth_token_hash") @db.VarChar(128)
+  status             String    @default("active") @db.VarChar(20)
+  keyVersion         Int       @default(1) @map("key_version")
+  lastKeyRotation    DateTime? @map("last_key_rotation")
+  lastSeenAt         DateTime? @map("last_seen_at")
+  lastIpAddress      String?   @map("last_ip_address") @db.VarChar(45)
+  batteryLevel       Int?      @map("battery_level")
+  signalStrength     Int?      @map("signal_strength")
+  totalSmsSent       Int       @default(0) @map("total_sms_sent")
+  totalSmsFailed     Int       @default(0) @map("total_sms_failed")
+  dailySmsSent       Int       @default(0) @map("daily_sms_sent")
+  dailyResetAt       DateTime? @map("daily_reset_at")
+  maxSmsPerMinute    Int       @default(20) @map("max_sms_per_minute")
+  maxSmsPerHour      Int       @default(200) @map("max_sms_per_hour")
+  maxSmsPerDay       Int       @default(1000) @map("max_sms_per_day")
+  pairedById         String    @map("paired_by_id") @db.Uuid
+  createdAt          DateTime  @default(now()) @map("created_at")
+  updatedAt          DateTime  @updatedAt @map("updated_at")
+
+  messages RelayMessageQueue[]
+
+  @@index([organizationId])
+  @@index([authTokenHash])
+  @@map("phone_relays")
+}
+
+model PhoneRelayPairing {
+  id                        String   @id @default(uuid()) @db.Uuid
+  organizationId            String   @map("organization_id") @db.Uuid
+  pairingToken              String   @unique @map("pairing_token") @db.VarChar(128)
+  serverPublicKey           String   @map("server_public_key") @db.Text
+  serverPrivateKeyEncrypted String   @map("server_private_key_encrypted") @db.Text
+  status                    String   @default("pending") @db.VarChar(20)
+  initiatedById             String   @map("initiated_by_id") @db.Uuid
+  expiresAt                 DateTime @map("expires_at")
+  createdAt                 DateTime @default(now()) @map("created_at")
+
+  @@index([pairingToken])
+  @@map("phone_relay_pairings")
+}
+
+model RelayMessageQueue {
+  id               String    @id @default(uuid()) @db.Uuid
+  relayId          String    @map("relay_id") @db.Uuid
+  organizationId   String    @map("organization_id") @db.Uuid
+  encryptedPayload String    @map("encrypted_payload") @db.Text
+  status           String    @default("pending") @db.VarChar(20)
+  attempts         Int       @default(0)
+  maxAttempts      Int       @default(3) @map("max_attempts")
+  nativeMessageId  String?   @map("native_message_id") @db.VarChar(200)
+  errorMessage     String?   @map("error_message") @db.Text
+  deliveryStatus   String?   @map("delivery_status") @db.VarChar(20)
+  sentToDeviceAt   DateTime? @map("sent_to_device_at")
+  ackedAt          DateTime? @map("acked_at")
+  expiresAt        DateTime  @map("expires_at")
+  createdAt        DateTime  @default(now()) @map("created_at")
+  updatedAt        DateTime  @updatedAt @map("updated_at")
+
+  relay PhoneRelay @relation(fields: [relayId], references: [id], onDelete: Cascade)
+
+  @@index([relayId, status])
+  @@index([expiresAt])
+  @@map("relay_message_queue")
+}