@imessaging/core 0.1.0

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@imessaging/core",
+  "version": "0.1.0",
+  "description": "Core messaging transport contracts and Telegram peer storage",
+  "keywords": [
+    "messaging",
+    "peer-cache",
+    "telegram",
+    "transport"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iconicompany/imessaging.git",
+    "directory": "packages/core"
+  },
+  "files": [
+    "src"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "type-check": "bunx tsgo --noEmit -p tsconfig.json",
+    "test": "bun test"
+  }
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export { MemoryPeerStore } from "./memory-peer-store";
+export { createPeerKey } from "./peer-key";
+export type {
+  MessageRecipient,
+  MessageTransport,
+  OutboundButton,
+  OutboundDocument,
+  OutboundMessage,
+  ResolvedPeer,
+  SendResult,
+  TelegramPeerStore,
+  TransportStatus,
+} from "./types";

package/src/memory-peer-store.ts

@@ -0,0 +1,40 @@
+import { createPeerKey } from "./peer-key";
+import type { MessageRecipient, ResolvedPeer, TelegramPeerStore } from "./types";
+
+type StoredPeer = {
+  peer: ResolvedPeer;
+  expiresAt?: number;
+};
+
+export class MemoryPeerStore implements TelegramPeerStore {
+  private readonly peers = new Map<string, StoredPeer>();
+
+  async get(accountId: string, recipient: MessageRecipient): Promise<ResolvedPeer | null> {
+    const key = createPeerKey(accountId, recipient);
+    const stored = this.peers.get(key);
+    if (!stored) {
+      return null;
+    }
+    if (stored.expiresAt && stored.expiresAt <= Date.now()) {
+      this.peers.delete(key);
+      return null;
+    }
+    return stored.peer;
+  }
+
+  async set(
+    accountId: string,
+    recipient: MessageRecipient,
+    peer: ResolvedPeer,
+    ttlSeconds?: number,
+  ): Promise<void> {
+    this.peers.set(createPeerKey(accountId, recipient), {
+      peer,
+      expiresAt: ttlSeconds ? Date.now() + ttlSeconds * 1000 : undefined,
+    });
+  }
+
+  async delete(accountId: string, recipient: MessageRecipient): Promise<void> {
+    this.peers.delete(createPeerKey(accountId, recipient));
+  }
+}

package/src/peer-key.ts

@@ -0,0 +1,25 @@
+import type { MessageRecipient } from "./types";
+
+function normalizeUsername(username: string): string {
+  return username.trim().replace(/^@/, "").toLowerCase();
+}
+
+export function createPeerKey(accountId: string, recipient: MessageRecipient): string {
+  const normalizedAccountId = accountId.trim();
+  if (!normalizedAccountId) {
+    throw new Error("accountId must not be empty");
+  }
+
+  if (recipient.type === "username") {
+    const username = normalizeUsername(recipient.username);
+    if (!username) {
+      throw new Error("username must not be empty");
+    }
+    return `telegram-peer:${normalizedAccountId}:username:${username}`;
+  }
+
+  if (!recipient.id.trim()) {
+    throw new Error("recipient id must not be empty");
+  }
+  return `telegram-peer:${normalizedAccountId}:${recipient.type}:${recipient.id}`;
+}

package/src/types.ts

@@ -0,0 +1,77 @@
+export type UsernameRecipient = {
+  type: "username";
+  username: string;
+};
+
+export type TelegramIdRecipient = {
+  type: "user" | "group" | "channel";
+  id: string;
+  username?: string;
+};
+
+export type MessageRecipient = UsernameRecipient | TelegramIdRecipient;
+
+export type OutboundDocument = {
+  data: Uint8Array;
+  filename: string;
+  caption?: string;
+  mimeType?: string;
+};
+
+export type OutboundButton = {
+  text: string;
+  url?: string;
+  callbackData?: string;
+};
+
+export type OutboundMessage = {
+  recipient: MessageRecipient;
+  text: string;
+  replyToMessageId?: number;
+  threadId?: number;
+  documents?: OutboundDocument[];
+  buttons?: OutboundButton[][];
+  parseMode?: "HTML" | "Markdown" | "MarkdownV2";
+  metadata?: Readonly<Record<string, unknown>>;
+};
+
+export type SendResult = {
+  transportId: string;
+  messageId: string;
+  recipientId: string;
+};
+
+export type TransportStatus = {
+  connected: boolean;
+  transportId: string;
+  accountId?: string;
+  lastActivityAt?: Date;
+  error?: string;
+};
+
+export interface MessageTransport {
+  readonly id: string;
+  connect(): Promise<void>;
+  disconnect(): Promise<void>;
+  send(message: OutboundMessage): Promise<SendResult>;
+  getStatus(): Promise<TransportStatus>;
+}
+
+export type ResolvedPeer = {
+  type: "user" | "group" | "channel";
+  id: string;
+  accessHash?: string;
+  username?: string;
+  resolvedAt: string;
+};
+
+export interface TelegramPeerStore {
+  get(accountId: string, recipient: MessageRecipient): Promise<ResolvedPeer | null>;
+  set(
+    accountId: string,
+    recipient: MessageRecipient,
+    peer: ResolvedPeer,
+    ttlSeconds?: number,
+  ): Promise<void>;
+  delete(accountId: string, recipient: MessageRecipient): Promise<void>;
+}