@molecule/api-resource-message 1.0.0

package/dist/service.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Message resource business logic.
+ *
+ * Uses the abstract DataStore from `@molecule/api-database` for all
+ * persistence — never raw SQL. Realtime broadcast is delegated to
+ * `@molecule/api-realtime` and is no-op when no realtime provider is
+ * bonded.
+ *
+ * @module
+ */
+import { type ListMessagesOptions, type Message, type MessageAttachment, type Thread } from './types.js';
+/**
+ * Canonicalises a (a, b) participant pair so that the lexicographically
+ * smaller value is always returned first. This guarantees `(x, y)` and
+ * `(y, x)` resolve to the same {@link Thread} row.
+ *
+ * @param a - First participant ID.
+ * @param b - Second participant ID.
+ * @returns A tuple `[participantAId, participantBId]` in canonical order.
+ * @throws {Error} If `a` and `b` refer to the same participant.
+ */
+export declare function canonicaliseParticipants(a: string, b: string): [string, string];
+/**
+ * Looks up the canonical thread between two participants, creating it
+ * lazily if none exists.
+ *
+ * @param a - First participant user ID.
+ * @param b - Second participant user ID.
+ * @returns The existing or newly-created thread.
+ */
+export declare function getOrCreateThread(a: string, b: string): Promise<Thread>;
+/**
+ * Retrieves a thread by ID.
+ *
+ * @param threadId - The thread ID.
+ * @returns The thread, or `null` if not found.
+ */
+export declare function getThreadById(threadId: string): Promise<Thread | null>;
+/**
+ * Lists threads a participant is part of, ordered by most recent activity.
+ *
+ * @param participantId - The user ID to list threads for.
+ * @param options - Pagination options.
+ * @returns Array of threads in descending `lastMessageAt` order.
+ */
+export declare function listThreadsForParticipant(participantId: string, options?: {
+    limit?: number;
+    offset?: number;
+}): Promise<Thread[]>;
+/**
+ * Sends a message in a thread. Updates `lastMessageAt` and bumps the
+ * recipient's `unreadCount*` counter, then broadcasts the new message
+ * over the bonded realtime provider (if any).
+ *
+ * @param threadId - The target thread ID.
+ * @param senderId - The sending participant's user ID.
+ * @param body - Message body. Must be non-empty after trimming.
+ * @param attachments - Optional attachment list.
+ * @returns The persisted message.
+ * @throws {Error} If the thread does not exist, the sender is not a
+ *   participant, or the body is empty.
+ */
+export declare function sendMessage(threadId: string, senderId: string, body: string, attachments?: MessageAttachment[]): Promise<Message>;
+/**
+ * Marks a thread as read for the given participant and resets their
+ * unread counter to zero. Broadcasts a `message:read` event.
+ *
+ * @param threadId - The thread ID.
+ * @param readerId - The participant user ID marking the thread as read.
+ * @throws {Error} If the thread does not exist or the reader is not a
+ *   participant.
+ */
+export declare function markRead(threadId: string, readerId: string): Promise<void>;
+/**
+ * Lists messages in a thread, newest first. Soft-deleted messages are
+ * still returned (with `deletedAt` set) so clients can render
+ * "this message was deleted" placeholders.
+ *
+ * @param threadId - The thread ID.
+ * @param options - Pagination options. `before` returns messages strictly
+ *   older than the given ISO timestamp; `limit` is clamped to 200.
+ * @returns Array of messages, newest first.
+ */
+export declare function listMessages(threadId: string, options?: ListMessagesOptions): Promise<Message[]>;
+/**
+ * Edits an existing message body. Only the original sender may edit.
+ *
+ * @param messageId - The message ID.
+ * @param senderId - The user ID claiming to be the message author.
+ * @param body - New non-empty message body.
+ * @returns The updated message, or `null` if not found / not authorised.
+ */
+export declare function editMessage(messageId: string, senderId: string, body: string): Promise<Message | null>;
+/**
+ * Soft-deletes a message. Only the original sender may delete.
+ *
+ * @param messageId - The message ID.
+ * @param senderId - The user ID claiming to be the message author.
+ * @returns `true` if the message was soft-deleted, `false` if not found
+ *   or not authorised.
+ */
+export declare function deleteMessage(messageId: string, senderId: string): Promise<boolean>;
+/**
+ * Counts unread messages for a participant across all of their threads.
+ *
+ * @param participantId - The participant user ID.
+ * @returns Total unread message count across every thread.
+ */
+export declare function getTotalUnreadCount(participantId: string): Promise<number>;
+/**
+ * Counts the messages persisted in a thread (including soft-deleted).
+ *
+ * @param threadId - The thread ID.
+ * @returns Total stored message count.
+ */
+export declare function countMessages(threadId: string): Promise<number>;
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAYH,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,OAAO,EAEZ,KAAK,iBAAiB,EACtB,KAAK,MAAM,EAEZ,MAAM,YAAY,CAAA;AAQnB;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAK/E;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAsB7E;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAE5E;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC7C,aAAa,EAAE,MAAM,EACrB,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAChD,OAAO,CAAC,MAAM,EAAE,CAAC,CA2BnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,WAAW,GAAE,iBAAiB,EAAO,GACpC,OAAO,CAAC,OAAO,CAAC,CAkDlB;AAED;;;;;;;;GAQG;AACH,wBAAsB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA4BhF;AAED;;;;;;;;;GASG;AACH,wBAAsB,YAAY,CAChC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,OAAO,EAAE,CAAC,CAepB;AAED;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAC/B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAgBzB;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAazF;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAiBhF;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAErE"}

package/dist/service.js

@@ -0,0 +1,301 @@
+/**
+ * Message resource business logic.
+ *
+ * Uses the abstract DataStore from `@molecule/api-database` for all
+ * persistence — never raw SQL. Realtime broadcast is delegated to
+ * `@molecule/api-realtime` and is no-op when no realtime provider is
+ * bonded.
+ *
+ * @module
+ */
+import { count, create as dbCreate, findById, findMany, findOne, updateById, } from '@molecule/api-database';
+import { broadcast, hasProvider as hasRealtimeProvider } from '@molecule/api-realtime';
+import { MESSAGE_REALTIME_EVENTS, threadRoomId, } from './types.js';
+const THREADS_TABLE = 'message_threads';
+const MESSAGES_TABLE = 'messages';
+const DEFAULT_PAGE_SIZE = 50;
+const MAX_PAGE_SIZE = 200;
+/**
+ * Canonicalises a (a, b) participant pair so that the lexicographically
+ * smaller value is always returned first. This guarantees `(x, y)` and
+ * `(y, x)` resolve to the same {@link Thread} row.
+ *
+ * @param a - First participant ID.
+ * @param b - Second participant ID.
+ * @returns A tuple `[participantAId, participantBId]` in canonical order.
+ * @throws {Error} If `a` and `b` refer to the same participant.
+ */
+export function canonicaliseParticipants(a, b) {
+    if (a === b) {
+        throw new Error('Cannot create a 1:1 thread with the same participant on both sides');
+    }
+    return a < b ? [a, b] : [b, a];
+}
+/**
+ * Looks up the canonical thread between two participants, creating it
+ * lazily if none exists.
+ *
+ * @param a - First participant user ID.
+ * @param b - Second participant user ID.
+ * @returns The existing or newly-created thread.
+ */
+export async function getOrCreateThread(a, b) {
+    const [participantAId, participantBId] = canonicaliseParticipants(a, b);
+    const existing = await findOne(THREADS_TABLE, [
+        { field: 'participantAId', operator: '=', value: participantAId },
+        { field: 'participantBId', operator: '=', value: participantBId },
+    ]);
+    if (existing)
+        return existing;
+    const result = await dbCreate(THREADS_TABLE, {
+        participantAId,
+        participantBId,
+        lastMessageAt: null,
+        unreadCountA: 0,
+        unreadCountB: 0,
+    });
+    if (!result.data) {
+        throw new Error('Failed to create message thread');
+    }
+    return result.data;
+}
+/**
+ * Retrieves a thread by ID.
+ *
+ * @param threadId - The thread ID.
+ * @returns The thread, or `null` if not found.
+ */
+export async function getThreadById(threadId) {
+    return findById(THREADS_TABLE, threadId);
+}
+/**
+ * Lists threads a participant is part of, ordered by most recent activity.
+ *
+ * @param participantId - The user ID to list threads for.
+ * @param options - Pagination options.
+ * @returns Array of threads in descending `lastMessageAt` order.
+ */
+export async function listThreadsForParticipant(participantId, options = {}) {
+    const limit = clampLimit(options.limit, DEFAULT_PAGE_SIZE);
+    const offset = options.offset ?? 0;
+    // Two queries unioned in memory because most DataStore backends do not
+    // expose OR filters on the abstract interface.
+    const [asA, asB] = await Promise.all([
+        findMany(THREADS_TABLE, {
+            where: [{ field: 'participantAId', operator: '=', value: participantId }],
+            orderBy: [{ field: 'lastMessageAt', direction: 'desc' }],
+            limit: limit + offset,
+        }),
+        findMany(THREADS_TABLE, {
+            where: [{ field: 'participantBId', operator: '=', value: participantId }],
+            orderBy: [{ field: 'lastMessageAt', direction: 'desc' }],
+            limit: limit + offset,
+        }),
+    ]);
+    const merged = [...asA, ...asB].sort((x, y) => {
+        const xt = x.lastMessageAt ?? '';
+        const yt = y.lastMessageAt ?? '';
+        if (xt === yt)
+            return x.id < y.id ? 1 : -1;
+        return xt < yt ? 1 : -1;
+    });
+    return merged.slice(offset, offset + limit);
+}
+/**
+ * Sends a message in a thread. Updates `lastMessageAt` and bumps the
+ * recipient's `unreadCount*` counter, then broadcasts the new message
+ * over the bonded realtime provider (if any).
+ *
+ * @param threadId - The target thread ID.
+ * @param senderId - The sending participant's user ID.
+ * @param body - Message body. Must be non-empty after trimming.
+ * @param attachments - Optional attachment list.
+ * @returns The persisted message.
+ * @throws {Error} If the thread does not exist, the sender is not a
+ *   participant, or the body is empty.
+ */
+export async function sendMessage(threadId, senderId, body, attachments = []) {
+    if (!body || !body.trim()) {
+        throw new Error('Message body must be non-empty');
+    }
+    const thread = await findById(THREADS_TABLE, threadId);
+    if (!thread) {
+        throw new Error(`Thread not found: ${threadId}`);
+    }
+    if (senderId !== thread.participantAId && senderId !== thread.participantBId) {
+        throw new Error('Sender is not a participant in this thread');
+    }
+    const now = new Date().toISOString();
+    const result = await dbCreate(MESSAGES_TABLE, {
+        threadId,
+        senderId,
+        body,
+        attachments,
+        createdAt: now,
+        editedAt: null,
+        deletedAt: null,
+    });
+    if (!result.data) {
+        throw new Error('Failed to persist message');
+    }
+    // Bump the recipient's unread counter and refresh lastMessageAt.
+    const recipientField = senderId === thread.participantAId ? 'unreadCountB' : 'unreadCountA';
+    const currentRecipientUnread = senderId === thread.participantAId ? thread.unreadCountB : thread.unreadCountA;
+    await updateById(THREADS_TABLE, threadId, {
+        lastMessageAt: now,
+        [recipientField]: currentRecipientUnread + 1,
+        updatedAt: now,
+    });
+    // Optional realtime broadcast — silently no-ops without a bonded provider.
+    if (hasRealtimeProvider()) {
+        try {
+            await broadcast(threadRoomId(threadId), MESSAGE_REALTIME_EVENTS.messageSent, result.data);
+        }
+        catch (_error) {
+            // Realtime delivery is best-effort; persistence already succeeded.
+        }
+    }
+    return result.data;
+}
+/**
+ * Marks a thread as read for the given participant and resets their
+ * unread counter to zero. Broadcasts a `message:read` event.
+ *
+ * @param threadId - The thread ID.
+ * @param readerId - The participant user ID marking the thread as read.
+ * @throws {Error} If the thread does not exist or the reader is not a
+ *   participant.
+ */
+export async function markRead(threadId, readerId) {
+    const thread = await findById(THREADS_TABLE, threadId);
+    if (!thread) {
+        throw new Error(`Thread not found: ${threadId}`);
+    }
+    if (readerId !== thread.participantAId && readerId !== thread.participantBId) {
+        throw new Error('Reader is not a participant in this thread');
+    }
+    const now = new Date().toISOString();
+    const counterField = readerId === thread.participantAId ? 'unreadCountA' : 'unreadCountB';
+    await updateById(THREADS_TABLE, threadId, {
+        [counterField]: 0,
+        updatedAt: now,
+    });
+    if (hasRealtimeProvider()) {
+        try {
+            await broadcast(threadRoomId(threadId), MESSAGE_REALTIME_EVENTS.messageRead, {
+                threadId,
+                readerId,
+                readAt: now,
+            });
+        }
+        catch (_error) {
+            // Best-effort; read-state is updated, broadcast failure is non-critical.
+        }
+    }
+}
+/**
+ * Lists messages in a thread, newest first. Soft-deleted messages are
+ * still returned (with `deletedAt` set) so clients can render
+ * "this message was deleted" placeholders.
+ *
+ * @param threadId - The thread ID.
+ * @param options - Pagination options. `before` returns messages strictly
+ *   older than the given ISO timestamp; `limit` is clamped to 200.
+ * @returns Array of messages, newest first.
+ */
+export async function listMessages(threadId, options = {}) {
+    const limit = clampLimit(options.limit, DEFAULT_PAGE_SIZE);
+    const where = [
+        { field: 'threadId', operator: '=', value: threadId },
+    ];
+    if (options.before) {
+        where.push({ field: 'createdAt', operator: '<', value: options.before });
+    }
+    return findMany(MESSAGES_TABLE, {
+        where,
+        orderBy: [{ field: 'createdAt', direction: 'desc' }],
+        limit,
+    });
+}
+/**
+ * Edits an existing message body. Only the original sender may edit.
+ *
+ * @param messageId - The message ID.
+ * @param senderId - The user ID claiming to be the message author.
+ * @param body - New non-empty message body.
+ * @returns The updated message, or `null` if not found / not authorised.
+ */
+export async function editMessage(messageId, senderId, body) {
+    if (!body || !body.trim()) {
+        throw new Error('Message body must be non-empty');
+    }
+    const existing = await findById(MESSAGES_TABLE, messageId);
+    if (!existing || existing.senderId !== senderId || existing.deletedAt) {
+        return null;
+    }
+    const now = new Date().toISOString();
+    const result = await updateById(MESSAGES_TABLE, messageId, {
+        body,
+        editedAt: now,
+    });
+    return result.data;
+}
+/**
+ * Soft-deletes a message. Only the original sender may delete.
+ *
+ * @param messageId - The message ID.
+ * @param senderId - The user ID claiming to be the message author.
+ * @returns `true` if the message was soft-deleted, `false` if not found
+ *   or not authorised.
+ */
+export async function deleteMessage(messageId, senderId) {
+    const existing = await findById(MESSAGES_TABLE, messageId);
+    if (!existing || existing.senderId !== senderId || existing.deletedAt) {
+        return false;
+    }
+    const now = new Date().toISOString();
+    await updateById(MESSAGES_TABLE, messageId, {
+        deletedAt: now,
+        body: '',
+        attachments: [],
+    });
+    return true;
+}
+/**
+ * Counts unread messages for a participant across all of their threads.
+ *
+ * @param participantId - The participant user ID.
+ * @returns Total unread message count across every thread.
+ */
+export async function getTotalUnreadCount(participantId) {
+    const [asA, asB] = await Promise.all([
+        findMany(THREADS_TABLE, {
+            where: [{ field: 'participantAId', operator: '=', value: participantId }],
+            limit: 1000,
+        }),
+        findMany(THREADS_TABLE, {
+            where: [{ field: 'participantBId', operator: '=', value: participantId }],
+            limit: 1000,
+        }),
+    ]);
+    const total = asA.reduce((sum, t) => sum + (t.unreadCountA ?? 0), 0) +
+        asB.reduce((sum, t) => sum + (t.unreadCountB ?? 0), 0);
+    return total;
+}
+/**
+ * Counts the messages persisted in a thread (including soft-deleted).
+ *
+ * @param threadId - The thread ID.
+ * @returns Total stored message count.
+ */
+export async function countMessages(threadId) {
+    return count(MESSAGES_TABLE, [{ field: 'threadId', operator: '=', value: threadId }]);
+}
+/**
+ * Clamps a caller-supplied page-size to `[1, MAX_PAGE_SIZE]`, falling back to `fallback` when absent or invalid.
+ */
+function clampLimit(value, fallback) {
+    if (!value || value <= 0)
+        return fallback;
+    return Math.min(value, MAX_PAGE_SIZE);
+}

package/dist/types.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Direct-message resource type definitions.
+ *
+ * Models 1:1 messaging between two participants. A `Thread` is the
+ * canonical conversation between participants A and B. Participants are
+ * canonicalised on insert so `(a, b)` and `(b, a)` resolve to the same
+ * thread. `unread_count_a` / `unread_count_b` track unread messages for
+ * each side.
+ *
+ * @module
+ */
+/**
+ * A 1:1 messaging thread between two participants.
+ *
+ * `participantAId` and `participantBId` are stored canonically — the
+ * smaller value (lexicographically) is always `participantAId`. Use
+ * {@link getOrCreateThread} to look up or create a thread between two
+ * users without worrying about ordering.
+ */
+export interface Thread {
+    /** Unique thread identifier. */
+    id: string;
+    /** Lexicographically-smaller participant ID. */
+    participantAId: string;
+    /** Lexicographically-larger participant ID. */
+    participantBId: string;
+    /** Timestamp of the most recent message, or `null` if no messages exist. */
+    lastMessageAt: string | null;
+    /** Number of messages participant A has not yet read. */
+    unreadCountA: number;
+    /** Number of messages participant B has not yet read. */
+    unreadCountB: number;
+    /** When the thread was created (ISO 8601). */
+    createdAt: string;
+    /** When the thread was last updated (ISO 8601). */
+    updatedAt: string;
+}
+/**
+ * A message attachment reference.
+ */
+export interface MessageAttachment {
+    /** Public or signed URL to the attachment payload. */
+    url: string;
+    /** MIME type of the attachment (e.g. `image/png`). */
+    mime: string;
+}
+/**
+ * A single message within a {@link Thread}.
+ *
+ * `editedAt` and `deletedAt` are `null` until the message is mutated. A
+ * soft-deleted message (`deletedAt !== null`) is preserved for audit /
+ * thread continuity but should not be rendered as content.
+ */
+export interface Message {
+    /** Unique message identifier. */
+    id: string;
+    /** Thread this message belongs to. */
+    threadId: string;
+    /** ID of the user who sent the message. */
+    senderId: string;
+    /** Message body text. */
+    body: string;
+    /** Optional file/image attachments. */
+    attachments: MessageAttachment[];
+    /** When the message was created (ISO 8601). */
+    createdAt: string;
+    /** When the message was last edited, or `null`. */
+    editedAt: string | null;
+    /** When the message was soft-deleted, or `null`. */
+    deletedAt: string | null;
+}
+/**
+ * Options for paginating messages within a thread.
+ */
+export interface ListMessagesOptions {
+    /** Return messages strictly older than this timestamp (ISO 8601). */
+    before?: string;
+    /** Maximum number of messages to return. Defaults to 50, max 200. */
+    limit?: number;
+}
+/**
+ * Realtime event names emitted by this package.
+ *
+ * Subscribers should listen on the room ID returned from
+ * {@link threadRoomId} for the thread they care about.
+ */
+export declare const MESSAGE_REALTIME_EVENTS: {
+    /** A new message was sent in the thread. Payload: {@link Message}. */
+    readonly messageSent: "message:sent";
+    /** A participant marked the thread as read. Payload: `{ threadId, readerId, readAt }`. */
+    readonly messageRead: "message:read";
+};
+/** Union of realtime event names. */
+export type MessageRealtimeEvent = (typeof MESSAGE_REALTIME_EVENTS)[keyof typeof MESSAGE_REALTIME_EVENTS];
+/**
+ * Returns the realtime room ID for a given thread.
+ *
+ * @param threadId - The thread ID.
+ * @returns The room ID consumers should subscribe to for thread events.
+ */
+export declare function threadRoomId(threadId: string): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;;GAOG;AACH,MAAM,WAAW,MAAM;IACrB,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,gDAAgD;IAChD,cAAc,EAAE,MAAM,CAAA;IACtB,+CAA+C;IAC/C,cAAc,EAAE,MAAM,CAAA;IACtB,4EAA4E;IAC5E,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,yDAAyD;IACzD,YAAY,EAAE,MAAM,CAAA;IACpB,yDAAyD;IACzD,YAAY,EAAE,MAAM,CAAA;IACpB,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAA;IACjB,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,sDAAsD;IACtD,GAAG,EAAE,MAAM,CAAA;IACX,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;;;GAMG;AACH,MAAM,WAAW,OAAO;IACtB,iCAAiC;IACjC,EAAE,EAAE,MAAM,CAAA;IACV,sCAAsC;IACtC,QAAQ,EAAE,MAAM,CAAA;IAChB,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAA;IAChB,yBAAyB;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,uCAAuC;IACvC,WAAW,EAAE,iBAAiB,EAAE,CAAA;IAChC,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAA;IACjB,mDAAmD;IACnD,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,oDAAoD;IACpD,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;IAClC,sEAAsE;;IAEtE,0FAA0F;;CAElF,CAAA;AAEV,qCAAqC;AACrC,MAAM,MAAM,oBAAoB,GAC9B,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,OAAO,uBAAuB,CAAC,CAAA;AAExE;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAErD"}

package/dist/types.js

@@ -0,0 +1,32 @@
+/**
+ * Direct-message resource type definitions.
+ *
+ * Models 1:1 messaging between two participants. A `Thread` is the
+ * canonical conversation between participants A and B. Participants are
+ * canonicalised on insert so `(a, b)` and `(b, a)` resolve to the same
+ * thread. `unread_count_a` / `unread_count_b` track unread messages for
+ * each side.
+ *
+ * @module
+ */
+/**
+ * Realtime event names emitted by this package.
+ *
+ * Subscribers should listen on the room ID returned from
+ * {@link threadRoomId} for the thread they care about.
+ */
+export const MESSAGE_REALTIME_EVENTS = {
+    /** A new message was sent in the thread. Payload: {@link Message}. */
+    messageSent: 'message:sent',
+    /** A participant marked the thread as read. Payload: `{ threadId, readerId, readAt }`. */
+    messageRead: 'message:read',
+};
+/**
+ * Returns the realtime room ID for a given thread.
+ *
+ * @param threadId - The thread ID.
+ * @returns The room ID consumers should subscribe to for thread events.
+ */
+export function threadRoomId(threadId) {
+    return `thread:${threadId}`;
+}

package/dist/validation.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Message resource input validation schemas.
+ *
+ * @module
+ */
+import { z } from 'zod';
+/**
+ * Schema for an individual message attachment.
+ */
+export declare const messageAttachmentSchema: z.ZodObject<{
+    url: z.ZodString;
+    mime: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Schema for `getOrCreateThread` request input.
+ */
+export declare const getOrCreateThreadSchema: z.ZodObject<{
+    participantId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Schema for `sendMessage` request input.
+ */
+export declare const sendMessageSchema: z.ZodObject<{
+    body: z.ZodString;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        mime: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+/**
+ * Schema for `editMessage` request input.
+ */
+export declare const editMessageSchema: z.ZodObject<{
+    body: z.ZodString;
+}, z.core.$strip>;
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;GAEG;AACH,eAAO,MAAM,uBAAuB;;;iBAKlC,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB;;iBAGlC,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;iBAK5B,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB;;iBAG5B,CAAA"}

package/dist/validation.js

@@ -0,0 +1,38 @@
+/**
+ * Message resource input validation schemas.
+ *
+ * @module
+ */
+import { z } from 'zod';
+/**
+ * Schema for an individual message attachment.
+ */
+export const messageAttachmentSchema = z.object({
+    /** Public or signed URL to the attachment. */
+    url: z.string().url().max(2048),
+    /** MIME type of the attachment. */
+    mime: z.string().min(1).max(255),
+});
+/**
+ * Schema for `getOrCreateThread` request input.
+ */
+export const getOrCreateThreadSchema = z.object({
+    /** The other participant's user ID. */
+    participantId: z.string().min(1).max(255),
+});
+/**
+ * Schema for `sendMessage` request input.
+ */
+export const sendMessageSchema = z.object({
+    /** Message body. Must be non-empty and at most 10,000 characters. */
+    body: z.string().min(1).max(10_000),
+    /** Optional attachments. */
+    attachments: z.array(messageAttachmentSchema).max(20).optional(),
+});
+/**
+ * Schema for `editMessage` request input.
+ */
+export const editMessageSchema = z.object({
+    /** Updated message body. Must be non-empty and at most 10,000 characters. */
+    body: z.string().min(1).max(10_000),
+});