@bruch/max-client 0.1.0

package/src/types/models.ts

@@ -0,0 +1,461 @@
+import type { Attachment } from "./attachments.ts";
+import { parseAttachment } from "./attachments.ts";
+import {
+  asArray,
+  asNumber,
+  asRecord,
+  asString,
+  optionalMaxId,
+  optionalRecord,
+  toMaxId,
+  type MaxId,
+} from "./utils.ts";
+
+export const ChatType = {
+  DIALOG: "DIALOG",
+  CHAT: "CHAT",
+  CHANNEL: "CHANNEL",
+} as const;
+
+export interface ReactionCounter {
+  count: number;
+  reaction: string;
+}
+
+export interface ReactionInfo {
+  totalCount: number;
+  counters: ReactionCounter[];
+  yourReaction: string | null;
+}
+
+export interface ReadState {
+  unread: number;
+  mark: number;
+}
+
+export interface MessageActions {
+  sendMessage(options: SendMessageOptions): Promise<Message | null>;
+  forwardMessage(options: ForwardMessageOptions): Promise<Message | null>;
+  editMessage(options: EditMessageOptions): Promise<Message>;
+  deleteMessage(options: { chatId: MaxId; messageIds: MaxId[]; forMe: boolean }): Promise<boolean>;
+  pinMessage(options: { chatId: MaxId; messageId: MaxId; notifyPin: boolean }): Promise<boolean>;
+  readMessage(messageId: MaxId, chatId: MaxId): Promise<ReadState>;
+  addReaction(chatId: MaxId, messageId: MaxId, reaction: string): Promise<ReactionInfo | null>;
+  removeReaction(chatId: MaxId, messageId: MaxId): Promise<ReactionInfo | null>;
+  getReactions(chatId: MaxId, messageIds: MaxId[]): Promise<Map<MaxId, ReactionInfo> | null>;
+  getMessages(chatId: MaxId, messageIds: MaxId[]): Promise<Message[]>;
+  fetchHistory(options: HistoryOptions): Promise<Message[] | null>;
+}
+
+export interface ChatActions {
+  leaveGroup(chatId: MaxId): Promise<void>;
+  leaveChannel(chatId: MaxId): Promise<void>;
+  deleteChat(chatId: MaxId, forMe: boolean): Promise<boolean>;
+  inviteUsersToGroup(chatId: MaxId, userIds: MaxId[]): Promise<Chat | null>;
+  removeUsersFromGroup(chatId: MaxId, userIds: MaxId[]): Promise<Chat | null>;
+}
+
+export interface UserActions {
+  addContact(contactId: MaxId): Promise<User>;
+  removeContact(contactId: MaxId): Promise<boolean>;
+  getChatId(firstUserId: MaxId, secondUserId: MaxId): MaxId;
+}
+
+export interface SendMessageOptions {
+  chatId: MaxId;
+  text: string;
+  replyTo?: MaxId | null;
+  attachments?: readonly unknown[] | null;
+  notify?: boolean;
+}
+
+export interface ForwardMessageOptions {
+  chatId: MaxId;
+  messageId: MaxId;
+  sourceChatId?: MaxId | null;
+  notify?: boolean;
+}
+
+export interface EditMessageOptions {
+  chatId: MaxId;
+  messageId: MaxId;
+  text: string;
+  attachments?: readonly unknown[] | null;
+}
+
+export interface HistoryOptions {
+  chatId: MaxId;
+  forward?: number;
+  backward?: number;
+  backwardTime?: number;
+  forwardTime?: number;
+  from?: number;
+  itemType?: string;
+  getChat?: boolean;
+  getMessages?: boolean;
+  interactive?: boolean;
+}
+
+export class Message {
+  readonly id: MaxId;
+  chatId: MaxId | null;
+  readonly sender: MaxId | null;
+  readonly text: string;
+  readonly time: number;
+  readonly type: string;
+  readonly cid: MaxId | null;
+  readonly attaches: Attachment[];
+  readonly stats: Record<string, unknown> | null;
+  readonly status: string | null;
+  readonly reactionInfo: ReactionInfo | null;
+  readonly options: number | Record<string, unknown> | null;
+  readonly previousMessageId: MaxId | null;
+  readonly ttl: boolean | null;
+  readonly unread: number | null;
+  readonly mark: number | null;
+  readonly elements: Record<string, unknown>[];
+  readonly raw: Readonly<Record<string, unknown>>;
+  private actions: MessageActions | null = null;
+
+  private constructor(payload: Record<string, unknown>) {
+    this.id = toMaxId(payload.id, "message.id");
+    this.chatId = optionalMaxId(payload.chatId, "message.chatId");
+    this.sender = optionalMaxId(payload.sender, "message.sender");
+    this.text = asString(payload.text);
+    this.time = asNumber(payload.time);
+    this.type = asString(payload.type);
+    this.cid = optionalMaxId(payload.cid, "message.cid");
+    this.attaches = asArray(payload.attaches).map(parseAttachment);
+    this.stats = optionalRecord(payload.stats);
+    this.status = typeof payload.status === "string" ? payload.status : null;
+    this.reactionInfo = parseReactionInfo(payload.reactionInfo);
+    this.options =
+      typeof payload.options === "number" || optionalRecord(payload.options) !== null
+        ? (payload.options as number | Record<string, unknown>)
+        : null;
+    this.previousMessageId = optionalMaxId(payload.prevMessageId, "message.prevMessageId");
+    this.ttl = typeof payload.ttl === "boolean" ? payload.ttl : null;
+    this.unread =
+      payload.unread === null || payload.unread === undefined ? null : asNumber(payload.unread);
+    this.mark = payload.mark === null || payload.mark === undefined ? null : asNumber(payload.mark);
+    this.elements = asArray(payload.elements).map((item) => asRecord(item, "element"));
+    this.raw = Object.freeze({ ...payload });
+  }
+
+  static fromPayload(value: unknown): Message {
+    return new Message(asRecord(value, "message"));
+  }
+
+  bind(actions: MessageActions): this {
+    this.actions = actions;
+    return this;
+  }
+
+  async reply(
+    text: string,
+    options: Omit<SendMessageOptions, "chatId" | "text" | "replyTo"> = {},
+  ): Promise<Message | null> {
+    return await this.requireActions().sendMessage({
+      ...options,
+      chatId: this.requireChatId(),
+      text,
+      replyTo: this.id,
+    });
+  }
+
+  async answer(
+    text: string,
+    options: Omit<SendMessageOptions, "chatId" | "text"> = {},
+  ): Promise<Message | null> {
+    return await this.requireActions().sendMessage({
+      ...options,
+      chatId: this.requireChatId(),
+      text,
+    });
+  }
+
+  async forward(chatId: MaxId, notify = true): Promise<Message | null> {
+    return await this.requireActions().forwardMessage({
+      chatId,
+      messageId: this.id,
+      sourceChatId: this.requireChatId(),
+      notify,
+    });
+  }
+
+  async edit(text: string, attachments?: readonly unknown[] | null): Promise<Message> {
+    return await this.requireActions().editMessage({
+      chatId: this.requireChatId(),
+      messageId: this.id,
+      text,
+      ...(attachments !== undefined ? { attachments } : {}),
+    });
+  }
+
+  async pin(notifyPin = true): Promise<boolean> {
+    return await this.requireActions().pinMessage({
+      chatId: this.requireChatId(),
+      messageId: this.id,
+      notifyPin,
+    });
+  }
+
+  async delete(forMe = false): Promise<boolean> {
+    return await this.requireActions().deleteMessage({
+      chatId: this.requireChatId(),
+      messageIds: [this.id],
+      forMe,
+    });
+  }
+
+  async read(): Promise<ReadState> {
+    return await this.requireActions().readMessage(this.id, this.requireChatId());
+  }
+
+  async react(reaction: string): Promise<ReactionInfo | null> {
+    return await this.requireActions().addReaction(this.requireChatId(), this.id, reaction);
+  }
+
+  async unreact(): Promise<ReactionInfo | null> {
+    return await this.requireActions().removeReaction(this.requireChatId(), this.id);
+  }
+
+  async getReactions(): Promise<ReactionInfo | null> {
+    return (
+      (await this.requireActions().getReactions(this.requireChatId(), [this.id]))?.get(this.id) ??
+      null
+    );
+  }
+
+  private requireActions(): MessageActions {
+    if (!this.actions) throw new Error("Message is not bound to a client");
+    return this.actions;
+  }
+
+  private requireChatId(): MaxId {
+    if (this.chatId === null) throw new Error("Message has no chatId");
+    return this.chatId;
+  }
+}
+
+export class Chat {
+  readonly id: MaxId;
+  readonly type: string;
+  readonly status: string;
+  readonly owner: MaxId;
+  readonly participants: Map<MaxId, number>;
+  readonly title: string | null;
+  readonly lastMessage: Message | null;
+  readonly pinnedMessage: Message | null;
+  readonly lastEventTime: number;
+  readonly link: string | null;
+  readonly description: string | null;
+  readonly raw: Readonly<Record<string, unknown>>;
+  private messageActions: MessageActions | null = null;
+  private chatActions: ChatActions | null = null;
+
+  private constructor(payload: Record<string, unknown>) {
+    this.id = toMaxId(payload.id, "chat.id");
+    this.type = asString(payload.type);
+    this.status = asString(payload.status);
+    this.owner = optionalMaxId(payload.owner, "chat.owner") ?? 0n;
+    this.participants = parseParticipants(payload.participants);
+    this.title = typeof payload.title === "string" ? payload.title : null;
+    this.lastMessage = payload.lastMessage ? Message.fromPayload(payload.lastMessage) : null;
+    this.pinnedMessage = payload.pinnedMessage ? Message.fromPayload(payload.pinnedMessage) : null;
+    this.lastEventTime = asNumber(payload.lastEventTime);
+    this.link = typeof payload.link === "string" ? payload.link : null;
+    this.description = typeof payload.description === "string" ? payload.description : null;
+    this.raw = Object.freeze({ ...payload });
+  }
+
+  static fromPayload(value: unknown): Chat {
+    return new Chat(asRecord(value, "chat"));
+  }
+
+  bind(messageActions: MessageActions, chatActions: ChatActions): this {
+    this.messageActions = messageActions;
+    this.chatActions = chatActions;
+    this.lastMessage?.bind(messageActions);
+    this.pinnedMessage?.bind(messageActions);
+    return this;
+  }
+
+  async answer(
+    text: string,
+    options: Omit<SendMessageOptions, "chatId" | "text"> = {},
+  ): Promise<Message | null> {
+    return await this.requireMessageActions().sendMessage({ ...options, chatId: this.id, text });
+  }
+
+  async history(options: Omit<HistoryOptions, "chatId"> = {}): Promise<Message[] | null> {
+    return await this.requireMessageActions().fetchHistory({ ...options, chatId: this.id });
+  }
+
+  async getMessage(messageId: MaxId): Promise<Message | null> {
+    return (await this.requireMessageActions().getMessages(this.id, [messageId]))[0] ?? null;
+  }
+
+  async getMessages(messageIds: MaxId[]): Promise<Message[]> {
+    return await this.requireMessageActions().getMessages(this.id, messageIds);
+  }
+
+  async leave(): Promise<void> {
+    const actions = this.requireChatActions();
+    if (this.type === ChatType.CHANNEL) await actions.leaveChannel(this.id);
+    else if (this.type === ChatType.CHAT) await actions.leaveGroup(this.id);
+    else throw new Error("Cannot leave a dialog");
+  }
+
+  async delete(forMe = true): Promise<boolean> {
+    return await this.requireChatActions().deleteChat(this.id, forMe);
+  }
+
+  async invite(userIds: MaxId[]): Promise<Chat | null> {
+    return await this.requireChatActions().inviteUsersToGroup(this.id, userIds);
+  }
+
+  async removeUsers(userIds: MaxId[]): Promise<Chat | null> {
+    return await this.requireChatActions().removeUsersFromGroup(this.id, userIds);
+  }
+
+  private requireMessageActions(): MessageActions {
+    if (!this.messageActions) throw new Error("Chat is not bound to a client");
+    return this.messageActions;
+  }
+  private requireChatActions(): ChatActions {
+    if (!this.chatActions) throw new Error("Chat is not bound to a client");
+    return this.chatActions;
+  }
+}
+
+export class User {
+  readonly id: MaxId;
+  readonly names: ReadonlyArray<{ firstName: string; lastName: string | null; name?: string }>;
+  readonly phone: MaxId | null;
+  readonly status: string | null;
+  readonly description: string | null;
+  readonly gender: string | number | null;
+  readonly link: string | null;
+  readonly webApp: Record<string, unknown> | string | null;
+  readonly raw: Readonly<Record<string, unknown>>;
+  private actions: UserActions | null = null;
+
+  private constructor(payload: Record<string, unknown>) {
+    this.id = toMaxId(payload.id, "user.id");
+    this.names = asArray(payload.names).map((item) => {
+      const name = asRecord(item, "name");
+      return {
+        firstName: asString(name.firstName),
+        lastName: typeof name.lastName === "string" ? name.lastName : null,
+        ...(typeof name.name === "string" ? { name: name.name } : {}),
+      };
+    });
+    this.phone = optionalMaxId(payload.phone, "user.phone");
+    this.status = typeof payload.status === "string" ? payload.status : null;
+    this.description = typeof payload.description === "string" ? payload.description : null;
+    this.gender =
+      typeof payload.gender === "string" || typeof payload.gender === "number"
+        ? payload.gender
+        : null;
+    this.link = typeof payload.link === "string" ? payload.link : null;
+    this.webApp =
+      typeof payload.webApp === "string" ? payload.webApp : optionalRecord(payload.webApp);
+    this.raw = Object.freeze({ ...payload });
+  }
+
+  static fromPayload(value: unknown): User {
+    return new User(asRecord(value, "user"));
+  }
+  bind(actions: UserActions): this {
+    this.actions = actions;
+    return this;
+  }
+  async addContact(): Promise<User> {
+    return await this.requireActions().addContact(this.id);
+  }
+  async removeContact(): Promise<boolean> {
+    return await this.requireActions().removeContact(this.id);
+  }
+  getChatId(userId: MaxId): MaxId {
+    return this.requireActions().getChatId(userId, this.id);
+  }
+  private requireActions(): UserActions {
+    if (!this.actions) throw new Error("User is not bound to a client");
+    return this.actions;
+  }
+}
+
+export class Profile {
+  readonly contact: User;
+  readonly profileOptions: number[] | null;
+  readonly raw: Readonly<Record<string, unknown>>;
+  private constructor(payload: Record<string, unknown>) {
+    this.contact = User.fromPayload(payload.contact);
+    const rawOptions = payload.profileOptions ?? payload.options;
+    this.profileOptions = Array.isArray(rawOptions)
+      ? rawOptions.map((item) => asNumber(item))
+      : null;
+    this.raw = Object.freeze({ ...payload });
+  }
+  static fromPayload(value: unknown): Profile {
+    return new Profile(asRecord(value, "profile"));
+  }
+}
+
+export interface MessageDeleteEvent {
+  chatId: MaxId;
+  messageIds: MaxId[];
+  chat?: Chat | null;
+  message?: Message | null;
+  ttl?: boolean;
+}
+export interface MessageReadEvent {
+  chatId: MaxId;
+  userId: MaxId | null;
+  mark: number;
+}
+export interface TypingEvent {
+  chatId: MaxId;
+  userId: MaxId;
+  typing: boolean;
+}
+export interface PresenceEvent {
+  userId: MaxId;
+  online: boolean;
+  lastSeen: number | null;
+  raw: Readonly<Record<string, unknown>>;
+}
+export interface ReactionUpdateEvent {
+  chatId: MaxId;
+  messageId: MaxId;
+  reactionInfo: ReactionInfo | null;
+}
+
+export function parseReactionInfo(value: unknown): ReactionInfo | null {
+  if (value === null || value === undefined) return null;
+  const payload = asRecord(value, "reactionInfo");
+  return {
+    totalCount: asNumber(payload.totalCount),
+    counters: asArray(payload.counters).map((item) => {
+      const counter = asRecord(item, "reactionCounter");
+      return { count: asNumber(counter.count), reaction: asString(counter.reaction) };
+    }),
+    yourReaction: typeof payload.yourReaction === "string" ? payload.yourReaction : null,
+  };
+}
+
+export function parseReadState(value: unknown): ReadState {
+  const payload = asRecord(value, "readState");
+  return { unread: asNumber(payload.unread), mark: asNumber(payload.mark) };
+}
+
+function parseParticipants(value: unknown): Map<MaxId, number> {
+  const result = new Map<MaxId, number>();
+  if (value instanceof Map) {
+    for (const [id, role] of value) result.set(toMaxId(id), asNumber(role));
+  } else if (value !== null && typeof value === "object") {
+    for (const [id, role] of Object.entries(value)) result.set(toMaxId(id), asNumber(role));
+  }
+  return result;
+}

package/src/types/utils.ts

@@ -0,0 +1,45 @@
+export type MaxId = bigint;
+
+export function toMaxId(value: unknown, field = "id"): MaxId {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "string" && /^-?\d+$/.test(value)) return BigInt(value);
+  if (typeof value === "number" && Number.isSafeInteger(value)) return BigInt(value);
+  throw new TypeError(`${field} must be a lossless integer`);
+}
+
+export function optionalMaxId(value: unknown, field = "id"): MaxId | null {
+  return value === null || value === undefined ? null : toMaxId(value, field);
+}
+
+export function asRecord(value: unknown, field = "payload"): Record<string, unknown> {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError(`${field} must be an object`);
+  }
+  return value as Record<string, unknown>;
+}
+
+export function optionalRecord(value: unknown): Record<string, unknown> | null {
+  return value !== null && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+export function asString(value: unknown, fallback = ""): string {
+  return typeof value === "string" ? value : fallback;
+}
+
+export function asNumber(value: unknown, fallback = 0): number {
+  if (typeof value === "bigint") {
+    const number = Number(value);
+    return Number.isSafeInteger(number) ? number : fallback;
+  }
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+export function asBoolean(value: unknown, fallback = false): boolean {
+  return typeof value === "boolean" ? value : fallback;
+}
+
+export function asArray(value: unknown): unknown[] {
+  return Array.isArray(value) ? value : [];
+}