hazo_chat 2.0.16 → 2.1.1

package/README.md

@@ -12,7 +12,7 @@ A full-featured React chat component library for 1-1 communication with document
 - 📄 **Document Viewer** - Built-in PDF and image viewer with expand/collapse toggle, download, and open in new tab actions
 - 👤 **User Profiles** - Avatar display and user information
 - 🔄 **Infinite Scroll** - Cursor-based pagination for message history
-- ✅ **Read Receipts** - Track message read status
+- ✅ **Read Receipts** - Automatic mark-as-read when messages become visible using Intersection Observer
 - 🗑️ **Soft Delete** - Delete messages with undo capability
 - 🎨 **Customizable** - TailwindCSS-based theming
 - 🚀 **API-First** - No server-side dependencies in client components
@@ -242,19 +242,28 @@ This section defines the visual design standards and component behavior specific
 
 **Message Timestamp Display:**
 - Location: Chat bubble footer (`ChatBubble`)
-- Only timestamp is displayed (no status icons for sent/unread messages)
 - Font size: `text-xs`
 - Color: `text-muted-foreground`
-- Format: 24-hour format (e.g., "10:37 AM", "15:51")
+- Time format: 24-hour format (e.g., "10:37", "15:51")
+- Date prefix: Messages before today show date in `dd/MMM` format (e.g., "02/Dec 10:37")
 - Timezone: Respects `timezone` prop (default: "GMT+10")
 
-**Read Receipt Indicator:**
+**Message Status Indicators (Sender's Messages Only):**
 - Location: Chat bubble footer, after timestamp
-- Icon: `IoCheckmarkDoneSharp` (from `react-icons/io5`)
-- Size: `h-4 w-4` (16px × 16px)
-- Color: `text-green-500`
-- Display condition: Only shown when `read_at` is not null AND message is from sender
 - Position: After timestamp with `gap-1` spacing
+- Size: `h-4 w-4` (16px × 16px)
+
+**Sent Indicator (Grey Single Check):**
+- Icon: `IoCheckmark` (from `react-icons/io5`)
+- Color: `text-muted-foreground` (grey)
+- Display condition: Shown when message is sent but `read_at` is null
+- Meaning: Message delivered but not yet read by recipient
+
+**Read Receipt (Green Double Check):**
+- Icon: `IoCheckmarkDoneSharp` (from `react-icons/io5`)
+- Color: `text-green-500` (green)
+- Display condition: Only shown when `read_at` is not null
+- Meaning: Message has been read by recipient
 
 #### Component Behavior
 
@@ -293,6 +302,20 @@ This section defines the visual design standards and component behavior specific
 - Indicator: Chevron icon (`IoChevronDown` when collapsed, `IoChevronUp` when expanded)
 - Default state: Collapsed when no references, expanded when references exist
 
+**Automatic Mark-as-Read:**
+- Detection: Uses Intersection Observer API to detect when messages become visible
+- Trigger threshold: Messages marked as read when 50% visible in the ScrollArea viewport
+- Scope: Only marks messages where the current user is the receiver (not the sender)
+- State tracking: Prevents duplicate marking using in-memory Set
+- API endpoint: Requires `PATCH /api/hazo_chat/messages/[id]/read` route
+- Visual indicator: Green double-checkmark (IoCheckmarkDoneSharp) appears after timestamp
+- Automatic: No user action required - messages are marked as read automatically when scrolled into view
+
+**Note:** The mark-as-read functionality requires:
+1. The `HazoChat` component (includes all hooks and logic)
+2. The API route for marking messages as read (see API Routes Setup below)
+3. Messages must be received by the current user (messages sent by current user are not marked)
+
 #### Layout Standards
 
 **Chat Input Area:**
@@ -476,6 +499,7 @@ hazo_chat requires these API endpoints:
 |----------|--------|-------------|
 | `/api/hazo_chat/messages` | GET | Fetch chat messages |
 | `/api/hazo_chat/messages` | POST | Send a new message |
+| `/api/hazo_chat/messages/[id]/read` | PATCH | Mark a message as read (automatic) |
 | `/api/hazo_chat/unread_count` | GET | Get unread message counts by reference_id (optional) |
 | `/api/hazo_auth/me` | GET | Get current authenticated user |
 | `/api/hazo_auth/profiles` | POST | Fetch user profiles by IDs |
@@ -501,6 +525,34 @@ const { GET, POST } = createMessagesHandler({
 export { GET, POST };
 ```
 
+```typescript
+// app/api/hazo_chat/messages/[id]/read/route.ts
+import { NextRequest } from 'next/server';
+import { createMarkAsReadHandler } from 'hazo_chat/api';
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+
+export const dynamic = 'force-dynamic';
+
+const { PATCH } = createMarkAsReadHandler({
+  getHazoConnect: () => getHazoConnectSingleton(),
+  // Optional: custom authentication
+  getUserIdFromRequest: async (request) => {
+    // Return user ID from your auth system
+    return request.cookies.get('user_id')?.value || null;
+  }
+});
+
+// Wrapper to handle Next.js App Router params
+async function handlePATCH(
+  request: NextRequest,
+  context: { params: { id: string } | Promise<{ id: string }> }
+) {
+  return PATCH(request, context);
+}
+
+export { handlePATCH as PATCH };
+```
+
 ### Custom Implementation
 
 If you need more control, implement the endpoints manually. See [SETUP_CHECKLIST.md](./SETUP_CHECKLIST.md) for detailed examples.

package/SETUP_CHECKLIST.md

@@ -56,12 +56,141 @@ npm install react react-dom next
 
 ## 3. Database Setup
 
-### Step 3.1: Create hazo_chat Table
+### Step 3.1: PostgreSQL Setup (Recommended)
 
-Run this SQL to create the chat messages table:
+For PostgreSQL databases, follow these steps to create the schema with UUID types, enums, and proper defaults.
+
+#### Step 3.1.1: Enable UUID Extension
+
+First, enable the UUID extension for generating UUIDs:
+
+```sql
+-- Enable UUID extension (required for gen_random_uuid())
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+-- OR for PostgreSQL 13+, use pgcrypto extension
+CREATE EXTENSION IF NOT EXISTS "pgcrypto";
+```
+
+#### Step 3.1.2: Create Enum Types (Optional but Recommended)
+
+Create enum types for reference types to ensure data integrity:
+
+```sql
+-- Create enum for reference types
+CREATE TYPE hazo_enum_chat_type AS ENUM ('chat', 'field', 'project', 'support', 'general');
+
+-- Note: If you need to add more enum values later, use:
+-- ALTER TYPE hazo_chat_reference_type ADD VALUE 'new_type';
+```
+
+#### Step 3.1.3: Create hazo_chat Table
+
+Create the chat messages table with UUID types and proper defaults:
+
+```sql
+-- hazo_chat table for storing chat messages (PostgreSQL)
+CREATE TABLE IF NOT EXISTS hazo_chat (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  reference_id UUID NOT NULL,
+  reference_type hazo_enum_chat_type DEFAULT 'chat' NOT NULL,
+  sender_user_id UUID NOT NULL,
+  receiver_user_id UUID NOT NULL,
+  message_text TEXT,
+  reference_list JSONB,
+  read_at TIMESTAMPTZ,
+  deleted_at TIMESTAMPTZ,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  changed_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- Performance indexes
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_reference_id ON hazo_chat(reference_id);
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_sender ON hazo_chat(sender_user_id);
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_receiver ON hazo_chat(receiver_user_id);
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_created ON hazo_chat(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_reference_type ON hazo_chat(reference_type);
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_read_at ON hazo_chat(read_at) WHERE read_at IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_deleted_at ON hazo_chat(deleted_at) WHERE deleted_at IS NOT NULL;
+
+-- Composite index for common query pattern
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_receiver_reference ON hazo_chat(receiver_user_id, reference_id);
+```
+
+**Alternative: Without Enum Type (More Flexible)**
+
+If you prefer flexibility over strict enum validation:
 
 ```sql
--- hazo_chat table for storing chat messages
+-- hazo_chat table with TEXT reference_type (more flexible)
+CREATE TABLE IF NOT EXISTS hazo_chat (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  reference_id UUID NOT NULL,
+  reference_type TEXT DEFAULT 'chat' NOT NULL,
+  sender_user_id UUID NOT NULL,
+  receiver_user_id UUID NOT NULL,
+  message_text TEXT,
+  reference_list JSONB,
+  read_at TIMESTAMPTZ,
+  deleted_at TIMESTAMPTZ,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  changed_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- Performance indexes (same as above)
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_reference_id ON hazo_chat(reference_id);
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_sender ON hazo_chat(sender_user_id);
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_receiver ON hazo_chat(receiver_user_id);
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_created ON hazo_chat(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_reference_type ON hazo_chat(reference_type);
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_read_at ON hazo_chat(read_at) WHERE read_at IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_deleted_at ON hazo_chat(deleted_at) WHERE deleted_at IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_hazo_chat_receiver_reference ON hazo_chat(receiver_user_id, reference_id);
+```
+
+#### Step 3.1.4: Ensure Users Table Exists (PostgreSQL)
+
+You need a users table with at least these fields:
+
+```sql
+-- Users table for PostgreSQL
+CREATE TABLE IF NOT EXISTS hazo_users (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  email_address VARCHAR(255) UNIQUE NOT NULL,
+  name VARCHAR(255),
+  profile_picture_url TEXT,
+  is_active BOOLEAN DEFAULT TRUE NOT NULL,
+  created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+  changed_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- Indexes for users table
+CREATE INDEX IF NOT EXISTS idx_hazo_users_email ON hazo_users(email_address);
+CREATE INDEX IF NOT EXISTS idx_hazo_users_active ON hazo_users(is_active) WHERE is_active = TRUE;
+```
+
+#### Step 3.1.5: Add Foreign Key Constraints (Optional)
+
+Add foreign key constraints for referential integrity:
+
+```sql
+-- Add foreign key constraints (optional but recommended)
+ALTER TABLE hazo_chat
+  ADD CONSTRAINT fk_hazo_chat_sender 
+    FOREIGN KEY (sender_user_id) 
+    REFERENCES hazo_users(id) 
+    ON DELETE RESTRICT,
+  ADD CONSTRAINT fk_hazo_chat_receiver 
+    FOREIGN KEY (receiver_user_id) 
+    REFERENCES hazo_users(id) 
+    ON DELETE RESTRICT;
+```
+
+### Step 3.2: SQLite Setup (Alternative)
+
+For SQLite databases (development/testing), use this simplified schema:
+
+```sql
+-- hazo_chat table for storing chat messages (SQLite)
 CREATE TABLE IF NOT EXISTS hazo_chat (
   id TEXT PRIMARY KEY,
   reference_id TEXT NOT NULL,
@@ -72,8 +201,8 @@ CREATE TABLE IF NOT EXISTS hazo_chat (
   reference_list TEXT,
   read_at TEXT,
   deleted_at TEXT,
-  created_at TEXT NOT NULL,
-  changed_at TEXT NOT NULL
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  changed_at TEXT NOT NULL DEFAULT (datetime('now'))
 );
 
 -- Performance indexes
@@ -83,9 +212,7 @@ CREATE INDEX IF NOT EXISTS idx_hazo_chat_receiver ON hazo_chat(receiver_user_id)
 CREATE INDEX IF NOT EXISTS idx_hazo_chat_created ON hazo_chat(created_at DESC);
 ```
 
-### Step 3.2: Ensure Users Table Exists
-
-You need a users table with at least these fields:
+**SQLite Users Table:**
 
 ```sql
 CREATE TABLE IF NOT EXISTS hazo_users (
@@ -94,12 +221,91 @@ CREATE TABLE IF NOT EXISTS hazo_users (
   name TEXT,
   profile_picture_url TEXT,
   is_active INTEGER DEFAULT 1,
-  created_at TEXT NOT NULL,
-  changed_at TEXT NOT NULL
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  changed_at TEXT NOT NULL DEFAULT (datetime('now'))
 );
 ```
 
+### Step 3.3: Key Differences Between PostgreSQL and SQLite
+
+| Feature | PostgreSQL | SQLite |
+|---------|-----------|--------|
+| **ID Type** | `UUID` with `gen_random_uuid()` default | `TEXT` (manual UUID generation) |
+| **Boolean** | `BOOLEAN` type with `TRUE`/`FALSE` | `INTEGER` with `0`/`1` |
+| **Timestamp** | `TIMESTAMPTZ` with `NOW()` default | `TEXT` with `datetime('now')` |
+| **JSON** | `JSONB` type (binary JSON) | `TEXT` (JSON string) |
+| **Enum** | Native `ENUM` type available | Not supported (use TEXT) |
+| **Extensions** | Requires UUID extension | No extensions needed |
+
+#### Step 3.3.1: Verify PostgreSQL Setup
+
+Run these queries to verify your PostgreSQL setup:
+
+```sql
+-- Verify UUID extension is enabled
+SELECT extname, extversion FROM pg_extension WHERE extname IN ('uuid-ossp', 'pgcrypto');
+
+-- Verify enum type exists (if using enum)
+SELECT typname FROM pg_type WHERE typname = 'hazo_chat_reference_type';
+
+-- Verify table structure
+SELECT 
+  column_name, 
+  data_type, 
+  column_default,
+  is_nullable
+FROM information_schema.columns 
+WHERE table_name = 'hazo_chat'
+ORDER BY ordinal_position;
+
+-- Verify indexes
+SELECT indexname, indexdef 
+FROM pg_indexes 
+WHERE tablename = 'hazo_chat';
+
+-- Test UUID generation
+SELECT gen_random_uuid() AS test_uuid;
+
+-- Test table insert with defaults (replace UUIDs with valid user IDs)
+INSERT INTO hazo_chat (
+  reference_id,
+  sender_user_id,
+  receiver_user_id,
+  message_text
+) VALUES (
+  gen_random_uuid(),
+  (SELECT id FROM hazo_users LIMIT 1),  -- Use existing user ID
+  (SELECT id FROM hazo_users LIMIT 1),  -- Use existing user ID
+  'Test message'
+);
+
+-- Verify auto-generated values
+SELECT 
+  id,
+  created_at,
+  changed_at,
+  reference_type
+FROM hazo_chat 
+WHERE message_text = 'Test message'
+LIMIT 1;
+
+-- Clean up test data
+DELETE FROM hazo_chat WHERE message_text = 'Test message';
+```
+
 ### Verification
+
+**PostgreSQL:**
+- [ ] UUID extension enabled (`uuid-ossp` or `pgcrypto`)
+- [ ] Enum type created (if using enum approach)
+- [ ] `hazo_chat` table exists with UUID columns
+- [ ] All indexes created successfully
+- [ ] Users table exists with UUID primary key
+- [ ] Can query: `SELECT * FROM hazo_chat LIMIT 1`
+- [ ] UUID default generation works: `INSERT INTO hazo_chat (...) VALUES (...)` generates UUID automatically
+- [ ] Timestamp defaults work: `created_at` and `changed_at` auto-populate
+
+**SQLite:**
 - [ ] `hazo_chat` table exists in database
 - [ ] Users table exists with at least one user
 - [ ] Can query: `SELECT * FROM hazo_chat LIMIT 1`
@@ -132,6 +338,41 @@ const { GET, POST } = createMessagesHandler({
 export { GET, POST };
 ```
 
+### Step 4.1.5: Mark as Read API (Automatic Read Receipts)
+
+**File: `src/app/api/hazo_chat/messages/[id]/read/route.ts`**
+
+```typescript
+/**
+ * API route to mark a chat message as read
+ * Uses the exportable handler from hazo_chat package
+ * Supports PATCH for marking messages as read
+ */
+
+export const dynamic = 'force-dynamic';
+
+import { NextRequest } from 'next/server';
+import { createMarkAsReadHandler } from 'hazo_chat/api';
+import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+
+// Create handler using the exportable factory from hazo_chat
+const { PATCH: patchHandler } = createMarkAsReadHandler({
+  getHazoConnect: () => getHazoConnectSingleton()
+});
+
+// Wrapper to handle Next.js App Router params
+async function PATCH(
+  request: NextRequest,
+  context: { params: { id: string } | Promise<{ id: string }> }
+) {
+  return patchHandler(request, context);
+}
+
+export { PATCH };
+```
+
+**Note:** This endpoint is called automatically by the `HazoChat` component when messages become visible in the viewport. It uses the Intersection Observer API to detect visibility and marks messages as read when they are at least 50% visible.
+
 ### Step 4.2: Auth Me API
 
 **File: `src/app/api/hazo_auth/me/route.ts`**
@@ -327,6 +568,7 @@ export async function GET(request: NextRequest) {
 | Endpoint | Method | File | Purpose |
 |----------|--------|------|---------|
 | `/api/hazo_chat/messages` | GET, POST | `api/hazo_chat/messages/route.ts` | Message CRUD |
+| `/api/hazo_chat/messages/[id]/read` | PATCH | `api/hazo_chat/messages/[id]/read/route.ts` | Mark message as read (automatic) |
 | `/api/hazo_chat/unread_count` | GET | `api/hazo_chat/unread_count/route.ts` | Get unread counts (optional) |
 | `/api/hazo_auth/me` | GET | `api/hazo_auth/me/route.ts` | Get current user |
 | `/api/hazo_auth/profiles` | POST | `api/hazo_auth/profiles/route.ts` | Get user profiles |
@@ -336,6 +578,7 @@ export async function GET(request: NextRequest) {
 - [ ] `GET /api/hazo_auth/me` returns user data when logged in
 - [ ] `POST /api/hazo_auth/profiles` returns profiles for given IDs
 - [ ] `GET /api/hazo_chat/messages?receiver_user_id=xxx` works
+- [ ] `PATCH /api/hazo_chat/messages/[message-id]/read` marks message as read
 - [ ] `GET /api/hazo_chat/unread_count?receiver_user_id=xxx` returns unread counts (if implemented)
 
 ---
@@ -880,6 +1123,19 @@ For detailed specifications, see the [UI Design Standards](#ui-design-standards)
 - [ ] No TypeScript errors
 
 ### Database Verification
+
+**PostgreSQL:**
+- [ ] UUID extension enabled (check with: `SELECT * FROM pg_extension WHERE extname = 'uuid-ossp' OR extname = 'pgcrypto';`)
+- [ ] Enum type created (if using): `SELECT typname FROM pg_type WHERE typname = 'hazo_chat_reference_type';`
+- [ ] `hazo_chat` table exists with correct column types
+- [ ] All indexes created (check with: `SELECT indexname FROM pg_indexes WHERE tablename = 'hazo_chat';`)
+- [ ] UUID default generation works: Test insert without providing ID
+- [ ] Timestamp defaults work: Test insert without providing timestamps
+- [ ] Boolean columns accept TRUE/FALSE values
+- [ ] Can insert and query messages
+- [ ] Foreign key constraints work (if enabled)
+
+**SQLite:**
 - [ ] `hazo_chat` table exists
 - [ ] Users table exists with test users
 - [ ] Can insert and query messages

package/dist/api/index.d.ts

@@ -18,9 +18,24 @@
  *
  * export { GET, POST };
  * ```
+ *
+ * @example
+ * ```typescript
+ * // app/api/hazo_chat/messages/[id]/route.ts
+ * import { createDeleteHandler } from 'hazo_chat/api';
+ * import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+ *
+ * export const dynamic = 'force-dynamic';
+ *
+ * const { DELETE } = createDeleteHandler({
+ *   getHazoConnect: () => getHazoConnectSingleton()
+ * });
+ *
+ * export { DELETE };
+ * ```
  */
-export { createMessagesHandler } from './messages.js';
+export { createMessagesHandler, createMarkAsReadHandler, createDeleteHandler, } from './messages.js';
 export { createUnreadCountFunction } from './unread_count.js';
-export type { MessagesHandlerOptions, ChatMessageInput, ChatMessageRecord } from './types.js';
+export type { MessagesHandlerOptions, ChatMessageInput, ChatMessageRecord, ApiErrorResponse, ApiSuccessResponse, PaginationMeta, } from './types.js';
 export type { UnreadCountFunctionOptions, UnreadCountResult } from './unread_count.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/api/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAG9D,YAAY,EACV,sBAAsB,EACtB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,0BAA0B,EAC1B,iBAAiB,EAClB,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAGH,OAAO,EACL,qBAAqB,EACrB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC;AAG9D,YAAY,EACV,sBAAsB,EACtB,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,GACf,MAAM,YAAY,CAAC;AACpB,YAAY,EAAE,0BAA0B,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/api/index.js

@@ -18,8 +18,23 @@
  *
  * export { GET, POST };
  * ```
+ *
+ * @example
+ * ```typescript
+ * // app/api/hazo_chat/messages/[id]/route.ts
+ * import { createDeleteHandler } from 'hazo_chat/api';
+ * import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+ *
+ * export const dynamic = 'force-dynamic';
+ *
+ * const { DELETE } = createDeleteHandler({
+ *   getHazoConnect: () => getHazoConnectSingleton()
+ * });
+ *
+ * export { DELETE };
+ * ```
  */
 // Export handler factories
-export { createMessagesHandler } from './messages.js';
+export { createMessagesHandler, createMarkAsReadHandler, createDeleteHandler, } from './messages.js';
 export { createUnreadCountFunction } from './unread_count.js';
 //# sourceMappingURL=index.js.map

package/dist/api/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,2BAA2B;AAC3B,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/api/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,2BAA2B;AAC3B,OAAO,EACL,qBAAqB,EACrB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/api/messages.d.ts

@@ -1,7 +1,7 @@
 /**
  * Messages API Handler Factory
  *
- * Creates GET and POST handlers for the /api/hazo_chat/messages endpoint.
+ * Creates GET, POST, and DELETE handlers for the /api/hazo_chat/messages endpoint.
  * These handlers should be used in a Next.js API route.
  *
  * @example
@@ -31,4 +31,55 @@ export declare function createMessagesHandler(options: MessagesHandlerOptions):
     GET: (request: NextRequest) => Promise<NextResponse>;
     POST: (request: NextRequest) => Promise<NextResponse>;
 };
+/**
+ * Creates a PATCH handler for marking a message as read
+ *
+ * This handler should be used in a Next.js API route like:
+ * /api/hazo_chat/messages/[id]/read/route.ts
+ *
+ * @param options - Configuration options
+ * @returns PATCH handler function
+ */
+export declare function createMarkAsReadHandler(options: MessagesHandlerOptions): {
+    PATCH: (request: NextRequest, context: {
+        params: {
+            id: string;
+        } | Promise<{
+            id: string;
+        }>;
+    }) => Promise<NextResponse>;
+};
+/**
+ * Creates a DELETE handler for soft-deleting a message
+ *
+ * This handler should be used in a Next.js API route like:
+ * /api/hazo_chat/messages/[id]/route.ts
+ *
+ * @example
+ * ```typescript
+ * // app/api/hazo_chat/messages/[id]/route.ts
+ * import { createDeleteHandler } from 'hazo_chat/api';
+ * import { getHazoConnectSingleton } from 'hazo_connect/nextjs/setup';
+ *
+ * export const dynamic = 'force-dynamic';
+ *
+ * const { DELETE } = createDeleteHandler({
+ *   getHazoConnect: () => getHazoConnectSingleton()
+ * });
+ *
+ * export { DELETE };
+ * ```
+ *
+ * @param options - Configuration options
+ * @returns DELETE handler function
+ */
+export declare function createDeleteHandler(options: MessagesHandlerOptions): {
+    DELETE: (request: NextRequest, context: {
+        params: {
+            id: string;
+        } | Promise<{
+            id: string;
+        }>;
+    }) => Promise<NextResponse>;
+};
 //# sourceMappingURL=messages.d.ts.map

package/dist/api/messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/api/messages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIxD,OAAO,KAAK,EAAE,sBAAsB,EAAuC,MAAM,YAAY,CAAC;AAmB9F;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,sBAAsB;mBAWvC,WAAW,KAAG,OAAO,CAAC,YAAY,CAAC;oBA+FlC,WAAW,KAAG,OAAO,CAAC,YAAY,CAAC;EA0GjE"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/api/messages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIxD,OAAO,KAAK,EAAE,sBAAsB,EAA6E,MAAM,YAAY,CAAC;AAkEpI;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,sBAAsB;mBAcvC,WAAW,KAAG,OAAO,CAAC,YAAY,CAAC;oBAoKlC,WAAW,KAAG,OAAO,CAAC,YAAY,CAAC;EAqIjE;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,sBAAsB;qBAY1D,WAAW,WACX;QAAE,MAAM,EAAE;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,GAAG,OAAO,CAAC;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,KAC5D,OAAO,CAAC,YAAY,CAAC;EA8HzB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,sBAAsB;sBAatD,WAAW,WACX;QAAE,MAAM,EAAE;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,GAAG,OAAO,CAAC;YAAE,EAAE,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,KAC5D,OAAO,CAAC,YAAY,CAAC;EAwHzB"}