@rizvanua/contact-chat 0.1.0

package/dist/index.js

@@ -0,0 +1,688 @@
+import { createHash } from 'crypto';
+import { Redis } from '@upstash/redis';
+
+// src/core/types.ts
+var MAX_MESSAGE_LENGTH = 1e3;
+var MAX_MESSAGES_PER_SESSION = 40;
+var SESSION_TTL_SECONDS = 604800;
+var RATE_PER_MINUTE = 5;
+var RATE_PER_DAY = 30;
+var DEFAULT_CHAT_LIMITS = {
+  maxMessageLength: MAX_MESSAGE_LENGTH,
+  maxMessagesPerSession: MAX_MESSAGES_PER_SESSION,
+  sessionTtlSeconds: SESSION_TTL_SECONDS,
+  ratePerMinute: RATE_PER_MINUTE,
+  ratePerDay: RATE_PER_DAY
+};
+
+// src/core/config.ts
+var DEFAULT_CHAT_SERVER_COPY = {
+  validation: {
+    malformedBody: "Malformed request body.",
+    missingSession: "Missing session.",
+    rejected: "Rejected.",
+    messageRequired: "Message is required.",
+    messageEmpty: "Message is empty.",
+    messageTooLong: (limit) => `Please keep it under ${limit} characters.`,
+    nameRequired: "Please tell me your name first."
+  },
+  rateLimited: "That is a lot of messages \u2014 please wait a moment.",
+  messageLimitReached: "This conversation has reached its message limit.",
+  storeUnavailable: "Chat is unavailable right now.",
+  telegramUnavailable: "Could not deliver that message."
+};
+function resolveConfig(config) {
+  return {
+    store: config.store,
+    transport: config.transport,
+    ipHashSalt: config.ipHashSalt,
+    limits: { ...DEFAULT_CHAT_LIMITS, ...config.limits },
+    copy: {
+      ...DEFAULT_CHAT_SERVER_COPY,
+      ...config.copy,
+      validation: {
+        ...DEFAULT_CHAT_SERVER_COPY.validation,
+        ...config.copy?.validation ?? {}
+      }
+    },
+    onError: config.onError ?? (() => {
+    })
+  };
+}
+var MINUTE_SECONDS = 60;
+var DAY_SECONDS = 86400;
+function getClientIp(headers) {
+  const forwarded = headers.get("x-forwarded-for");
+  if (forwarded) {
+    const first = forwarded.split(",")[0]?.trim();
+    if (first) return first;
+  }
+  return headers.get("x-real-ip")?.trim() || "unknown";
+}
+function hashIp(ip, salt) {
+  return createHash("sha256").update(`${ip}:${salt}`).digest("hex").slice(0, 32);
+}
+async function checkRateLimit(ip, deps) {
+  const id = hashIp(ip, deps.ipHashSalt);
+  const perMinute = await deps.store.incrementCounter(`chat:rate:${id}:min`, MINUTE_SECONDS);
+  if (perMinute > deps.limits.ratePerMinute) {
+    return { allowed: false, retryAfterSeconds: MINUTE_SECONDS };
+  }
+  const perDay = await deps.store.incrementCounter(`chat:rate:${id}:day`, DAY_SECONDS);
+  if (perDay > deps.limits.ratePerDay) {
+    return { allowed: false, retryAfterSeconds: DAY_SECONDS };
+  }
+  return { allowed: true, retryAfterSeconds: 0 };
+}
+
+// src/core/name.ts
+var MAX_NAME_LENGTH = 60;
+function sanitizeName(raw) {
+  if (typeof raw !== "string") return "";
+  return raw.replace(/[\u0000-\u001F\u007F]/g, " ").replace(/\s+/g, " ").trim().slice(0, MAX_NAME_LENGTH);
+}
+
+// src/core/handlers.ts
+var TransportFailure = class extends Error {
+  constructor(cause) {
+    super("transport failure");
+    this.cause = cause;
+  }
+  cause;
+};
+async function callTransport(op) {
+  try {
+    return await op();
+  } catch (error) {
+    throw new TransportFailure(error);
+  }
+}
+function fail(status, body, headers) {
+  return Response.json(body, { status, headers });
+}
+function createSendHandler(resolved) {
+  const { store, transport, limits, copy, ipHashSalt, onError } = resolved;
+  return async function sendHandler(request) {
+    let payload;
+    try {
+      payload = await request.json();
+    } catch {
+      return fail(400, { code: "validation", error: copy.validation.malformedBody });
+    }
+    const { sessionId, text, name, honeypot } = payload ?? {};
+    if (typeof sessionId !== "string" || sessionId.length < 8) {
+      return fail(400, { code: "validation", error: copy.validation.missingSession });
+    }
+    if (typeof honeypot === "string" && honeypot.length > 0) {
+      return fail(400, { code: "validation", error: copy.validation.rejected });
+    }
+    if (typeof text !== "string") {
+      return fail(400, { code: "validation", error: copy.validation.messageRequired });
+    }
+    const trimmed = text.trim();
+    if (trimmed.length === 0) {
+      return fail(400, { code: "validation", error: copy.validation.messageEmpty });
+    }
+    if (trimmed.length > limits.maxMessageLength) {
+      return fail(400, {
+        code: "validation",
+        error: copy.validation.messageTooLong(limits.maxMessageLength)
+      });
+    }
+    try {
+      const limit = await checkRateLimit(getClientIp(request.headers), {
+        store,
+        ipHashSalt,
+        limits
+      });
+      if (!limit.allowed) {
+        return fail(
+          429,
+          {
+            code: "rate_limited",
+            error: copy.rateLimited
+          },
+          { "Retry-After": String(limit.retryAfterSeconds) }
+        );
+      }
+      let session = await store.getSession(sessionId);
+      if (session && session.msgCount >= limits.maxMessagesPerSession) {
+        return fail(400, {
+          code: "validation",
+          error: copy.messageLimitReached
+        });
+      }
+      const userAgent = request.headers.get("user-agent");
+      if (!session) {
+        const visitorName = sanitizeName(name);
+        if (!visitorName) {
+          return fail(400, {
+            code: "validation",
+            error: copy.validation.nameRequired
+          });
+        }
+        const topicId = await callTransport(
+          () => transport.createThread({ name: visitorName, userAgent, now: /* @__PURE__ */ new Date() })
+        );
+        session = await store.createSession(sessionId, topicId, visitorName);
+      } else if (!session.name) {
+        const visitorName = sanitizeName(name);
+        if (visitorName) {
+          const updated = await store.setSessionName(sessionId, visitorName);
+          if (updated) session = updated;
+          try {
+            await callTransport(
+              () => transport.renameThread(session.topicId, {
+                name: visitorName,
+                userAgent,
+                // First contact, matching how a fresh topic is stamped.
+                now: new Date(session.createdAt)
+              })
+            );
+          } catch (error) {
+            onError(
+              "chat.send.topicRename",
+              error instanceof TransportFailure ? error.cause : error
+            );
+          }
+        }
+      }
+      try {
+        await callTransport(() => transport.send(session.topicId, trimmed));
+      } catch (error) {
+        const inner = error instanceof TransportFailure ? error.cause : error;
+        if (!transport.isMissingThreadError(inner)) throw error;
+        onError(
+          "chat.send.topicRecreate",
+          `topic ${session.topicId} is gone, recreating for session ${sessionId}`
+        );
+        const topicId = await callTransport(
+          () => transport.createThread({
+            name: session.name ?? "Visitor",
+            userAgent,
+            now: /* @__PURE__ */ new Date()
+          })
+        );
+        session = await store.retopicSession(sessionId, session, topicId);
+        await callTransport(() => transport.send(topicId, trimmed));
+      }
+      const message = {
+        id: crypto.randomUUID(),
+        from: "visitor",
+        text: trimmed,
+        ts: Date.now()
+      };
+      const cursor = await store.appendMessage(sessionId, message);
+      const body = { message, cursor };
+      return Response.json(body);
+    } catch (error) {
+      if (error instanceof TransportFailure) {
+        onError("chat.send.telegram", error.cause);
+        return fail(502, {
+          code: "telegram_unavailable",
+          error: copy.telegramUnavailable
+        });
+      }
+      onError(
+        "chat.send",
+        error instanceof Error ? error.message : error
+      );
+      return fail(503, {
+        code: "store_unavailable",
+        error: copy.storeUnavailable
+      });
+    }
+  };
+}
+function createPollHandler(resolved) {
+  const { store, copy } = resolved;
+  return async function pollHandler(request) {
+    const url = new URL(request.url);
+    const sessionId = url.searchParams.get("sessionId");
+    const since = Number(url.searchParams.get("since") ?? "0");
+    if (!sessionId || sessionId.length < 8) {
+      const body = {
+        code: "validation",
+        error: copy.validation.missingSession
+      };
+      return Response.json(body, { status: 400 });
+    }
+    try {
+      const { messages, cursor } = await store.getMessagesSince(
+        sessionId,
+        Number.isFinite(since) ? since : 0
+      );
+      const body = { messages, cursor };
+      return Response.json(body, {
+        headers: { "Cache-Control": "no-store" }
+      });
+    } catch {
+      const body = {
+        code: "store_unavailable",
+        error: copy.storeUnavailable
+      };
+      return Response.json(body, { status: 503 });
+    }
+  };
+}
+function createWebhookHandler(resolved) {
+  const { store, transport } = resolved;
+  const ok = () => Response.json({ ok: true });
+  return async function webhookHandler(request) {
+    if (!transport.verifyWebhook(request)) {
+      return Response.json({ ok: false }, { status: 401 });
+    }
+    let update;
+    try {
+      update = await request.json();
+    } catch {
+      return ok();
+    }
+    const reply = transport.parseInboundReply(update);
+    if (!reply) return ok();
+    try {
+      const sessionId = await store.resolveTopic(reply.threadId);
+      if (!sessionId) return ok();
+      const message = {
+        id: `tg-${reply.messageId}`,
+        from: "owner",
+        text: reply.text,
+        ts: Date.now()
+      };
+      await store.appendMessage(sessionId, message);
+    } catch {
+    }
+    return ok();
+  };
+}
+
+// src/core/index.ts
+function createChatServer(config) {
+  const resolved = resolveConfig(config);
+  return {
+    send: createSendHandler(resolved),
+    poll: createPollHandler(resolved),
+    webhook: createWebhookHandler(resolved)
+  };
+}
+function upstashRedisStore(opts) {
+  const redis = new Redis({ url: opts.url, token: opts.token });
+  const ttlSeconds = opts.ttlSeconds ?? DEFAULT_CHAT_LIMITS.sessionTtlSeconds;
+  const sessionKey = (sessionId) => `chat:sess:${sessionId}`;
+  const topicKey = (topicId) => `chat:topic:${topicId}`;
+  const messagesKey = (sessionId) => `chat:msgs:${sessionId}`;
+  async function writeSession(sessionId, session) {
+    await redis.set(sessionKey(sessionId), session, { ex: ttlSeconds });
+    await redis.set(topicKey(session.topicId), sessionId, {
+      ex: ttlSeconds
+    });
+  }
+  return {
+    async getSession(sessionId) {
+      const raw = await redis.get(sessionKey(sessionId));
+      return raw ?? null;
+    },
+    async createSession(sessionId, topicId, name) {
+      const session = {
+        topicId,
+        createdAt: Date.now(),
+        msgCount: 0,
+        name
+      };
+      await writeSession(sessionId, session);
+      return session;
+    },
+    /**
+     * Adopts a name onto an existing session. Returns null when the session has
+     * expired between the caller's read and this write.
+     */
+    async setSessionName(sessionId, name) {
+      const session = await this.getSession(sessionId);
+      if (!session) return null;
+      const next = { ...session, name };
+      await writeSession(sessionId, next);
+      return next;
+    },
+    /**
+     * Points a session at a replacement topic, dropping the reverse mapping for
+     * the old one so a recycled thread id can never resolve to a stale session.
+     */
+    async retopicSession(sessionId, session, topicId) {
+      if (session.topicId !== topicId) {
+        await redis.del(topicKey(session.topicId));
+      }
+      const next = { ...session, topicId };
+      await writeSession(sessionId, next);
+      return next;
+    },
+    async resolveTopic(topicId) {
+      return await redis.get(topicKey(topicId)) ?? null;
+    },
+    /**
+     * Appends a message and returns the new cursor (the list length).
+     *
+     * msgCount is incremented only for visitor messages, so the owner's replies
+     * never consume the visitor's per-session message budget.
+     */
+    async appendMessage(sessionId, message) {
+      const cursor = await redis.rpush(messagesKey(sessionId), message);
+      await redis.expire(messagesKey(sessionId), ttlSeconds);
+      const session = await this.getSession(sessionId);
+      if (session) {
+        await writeSession(sessionId, {
+          ...session,
+          msgCount: message.from === "visitor" ? session.msgCount + 1 : session.msgCount
+        });
+      }
+      return cursor;
+    },
+    async getMessagesSince(sessionId, since) {
+      const start = Number.isFinite(since) && since > 0 ? Math.floor(since) : 0;
+      const messages = await redis.lrange(
+        messagesKey(sessionId),
+        start,
+        -1
+      );
+      return { messages, cursor: start + messages.length };
+    },
+    /**
+     * INCR returns the post-increment value, so a fresh key returns 1 and EXPIRE is
+     * set only on that first hit. That keeps the window fixed rather than sliding
+     * forward on every request, which would make the limit unreachable.
+     */
+    async incrementCounter(key, ttlSeconds2) {
+      const count = await redis.incr(key);
+      if (count === 1) await redis.expire(key, ttlSeconds2);
+      return count;
+    }
+  };
+}
+
+// src/stores/memory.ts
+var inMemoryStoreKeysSymbol = /* @__PURE__ */ Symbol.for("contact-chat.inMemoryStore.keys");
+function inMemoryStore(opts) {
+  const ttlSeconds = opts?.ttlSeconds ?? DEFAULT_CHAT_LIMITS.sessionTtlSeconds;
+  const now = opts?.now ?? Date.now;
+  const sessions = /* @__PURE__ */ new Map();
+  const topics = /* @__PURE__ */ new Map();
+  const messages = /* @__PURE__ */ new Map();
+  const counters = /* @__PURE__ */ new Map();
+  const sessionKey = (sessionId) => `chat:sess:${sessionId}`;
+  const topicKey = (topicId) => `chat:topic:${topicId}`;
+  const messagesKey = (sessionId) => `chat:msgs:${sessionId}`;
+  function writeSession(sessionId, session) {
+    const expiresAt = now() + ttlSeconds * 1e3;
+    sessions.set(sessionKey(sessionId), {
+      session: structuredClone(session),
+      expiresAt
+    });
+    topics.set(topicKey(session.topicId), sessionId);
+  }
+  function getStoredSession(sessionId) {
+    const stored = sessions.get(sessionKey(sessionId));
+    if (!stored) return null;
+    if (stored.expiresAt <= now()) {
+      sessions.delete(sessionKey(sessionId));
+      return null;
+    }
+    return structuredClone(stored.session);
+  }
+  const store = {
+    async getSession(sessionId) {
+      return getStoredSession(sessionId);
+    },
+    async createSession(sessionId, topicId, name) {
+      const session = {
+        topicId,
+        createdAt: now(),
+        msgCount: 0,
+        name
+      };
+      writeSession(sessionId, session);
+      return structuredClone(session);
+    },
+    /**
+     * Adopts a name onto an existing session. Returns null when the session has
+     * expired between the caller's read and this write.
+     */
+    async setSessionName(sessionId, name) {
+      const session = getStoredSession(sessionId);
+      if (!session) return null;
+      const next = { ...session, name };
+      writeSession(sessionId, next);
+      return structuredClone(next);
+    },
+    /**
+     * Points a session at a replacement topic, dropping the reverse mapping for
+     * the old one so a recycled thread id can never resolve to a stale session.
+     */
+    async retopicSession(sessionId, session, topicId) {
+      if (session.topicId !== topicId) {
+        topics.delete(topicKey(session.topicId));
+      }
+      const next = { ...session, topicId };
+      writeSession(sessionId, next);
+      return structuredClone(next);
+    },
+    async resolveTopic(topicId) {
+      const key = topicKey(topicId);
+      const sessionId = topics.get(key);
+      if (!sessionId) return null;
+      const session = getStoredSession(sessionId);
+      if (!session) {
+        topics.delete(key);
+        return null;
+      }
+      return sessionId;
+    },
+    /**
+     * Appends a message and returns the new cursor (the list length).
+     *
+     * msgCount is incremented only for visitor messages, so the owner's replies
+     * never consume the visitor's per-session message budget.
+     */
+    async appendMessage(sessionId, message) {
+      const key = messagesKey(sessionId);
+      const expiresAt = now() + ttlSeconds * 1e3;
+      const stored = messages.get(key);
+      const existing = stored && stored.expiresAt > now() ? stored : null;
+      const list = existing ? [...existing.messages] : [];
+      list.push(structuredClone(message));
+      messages.set(key, { messages: list, expiresAt });
+      const session = getStoredSession(sessionId);
+      if (session) {
+        writeSession(sessionId, {
+          ...session,
+          msgCount: message.from === "visitor" ? session.msgCount + 1 : session.msgCount
+        });
+      }
+      return list.length;
+    },
+    async getMessagesSince(sessionId, since) {
+      const start = Number.isFinite(since) && since > 0 ? Math.floor(since) : 0;
+      const key = messagesKey(sessionId);
+      const stored = messages.get(key);
+      if (!stored || stored.expiresAt <= now()) {
+        return { messages: [], cursor: start };
+      }
+      const slice = stored.messages.slice(start);
+      return { messages: structuredClone(slice), cursor: start + slice.length };
+    },
+    /**
+     * INCR returns the post-increment value, so a fresh key returns 1 and EXPIRE is
+     * set only on that first hit. That keeps the window fixed rather than sliding
+     * forward on every request, which would make the limit unreachable.
+     */
+    async incrementCounter(key, ttlSeconds2) {
+      const existing = counters.get(key);
+      if (!existing || existing.expiresAt <= now()) {
+        counters.set(key, { count: 1, expiresAt: now() + ttlSeconds2 * 1e3 });
+        return 1;
+      }
+      existing.count++;
+      return existing.count;
+    },
+    /** Internal accessor for tests — not part of the ChatStore interface. */
+    [inMemoryStoreKeysSymbol]() {
+      return [
+        ...sessions.keys(),
+        ...topics.keys(),
+        ...messages.keys(),
+        ...counters.keys()
+      ];
+    }
+  };
+  return store;
+}
+
+// src/transports/telegram.ts
+var TelegramError = class extends Error {
+  constructor(message, description) {
+    super(message);
+    this.description = description;
+  }
+  description;
+};
+function isMissingThreadError(error) {
+  if (!(error instanceof TelegramError)) return false;
+  const detail = (error.description ?? error.message).toLowerCase();
+  return detail.includes("thread not found") || detail.includes("topic_deleted") || detail.includes("topic was deleted") || detail.includes("thread_not_found");
+}
+var API_BASE = "https://api.telegram.org";
+function describeBrowser(userAgent) {
+  if (!userAgent) return "Unknown browser";
+  if (/edg\//i.test(userAgent)) return "Edge";
+  if (/opr\//i.test(userAgent)) return "Opera";
+  if (/chrome\//i.test(userAgent)) return "Chrome";
+  if (/firefox\//i.test(userAgent)) return "Firefox";
+  if (/safari\//i.test(userAgent)) return "Safari";
+  return "Unknown browser";
+}
+function buildTopicName(input) {
+  const parts = new Intl.DateTimeFormat("en-GB", {
+    timeZone: "Europe/Kyiv",
+    day: "2-digit",
+    month: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  }).formatToParts(input.now);
+  const at = (type) => parts.find((part) => part.type === type)?.value ?? "00";
+  return [
+    input.name,
+    at("day"),
+    at("month"),
+    at("hour"),
+    at("minute"),
+    describeBrowser(input.userAgent)
+  ].join("-").slice(0, 128);
+}
+function telegramTransport(opts) {
+  const {
+    botToken,
+    chatId,
+    webhookSecret,
+    topicIconColor = 13338331,
+    buildTopicName: buildTopicNameFn = buildTopicName,
+    fetch: fetchFn = globalThis.fetch
+  } = opts;
+  if (!botToken) {
+    throw new Error("telegramTransport: botToken is required.");
+  }
+  if (!chatId) {
+    throw new Error("telegramTransport: chatId is required.");
+  }
+  if (!webhookSecret) {
+    throw new Error(
+      "telegramTransport: webhookSecret is required. Pass the same value you configured with Telegram via /setWebhook."
+    );
+  }
+  async function callApi(method, body) {
+    const response = await fetchFn(`${API_BASE}/bot${botToken}/${method}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      cache: "no-store"
+    });
+    const payload = await response.json();
+    if (!response.ok || !payload.ok) {
+      throw new TelegramError(
+        `${method} failed: ${payload.description ?? response.status}`,
+        payload.description
+      );
+    }
+    return payload.result;
+  }
+  return {
+    async createThread(input) {
+      const name = buildTopicNameFn(input);
+      const result = await callApi(
+        "createForumTopic",
+        {
+          chat_id: chatId,
+          name: name.slice(0, 128),
+          // Telegram snaps icon_color to a fixed six-colour palette and silently
+          // substitutes the nearest allowed value. 0xCB86DB is the purple one;
+          // an arbitrary brand hex such as 0x9333EA comes back as blue.
+          icon_color: topicIconColor
+        }
+      );
+      return result.message_thread_id;
+    },
+    async send(threadId, text) {
+      await callApi("sendMessage", {
+        chat_id: chatId,
+        message_thread_id: threadId,
+        text
+      });
+    },
+    /**
+     * Retitles an existing topic. Needed when a session created before the name
+     * gate shipped supplies a name for the first time — the topic already exists,
+     * so it has to be renamed rather than created.
+     */
+    async renameThread(threadId, input) {
+      const name = buildTopicNameFn(input);
+      await callApi("editForumTopic", {
+        chat_id: chatId,
+        message_thread_id: threadId,
+        name: name.slice(0, 128)
+      });
+    },
+    isMissingThreadError,
+    /**
+     * Narrows an inbound webhook update to an owner reply, or null.
+     *
+     * Every inbound filter lives here: not a message, sent by a bot, missing a
+     * message_thread_id (i.e. posted in the group's General area rather than a
+     * topic), or from an unexpected chat all return null.
+     */
+    parseInboundReply(update) {
+      if (typeof update !== "object" || update === null) return null;
+      const message = update.message;
+      if (typeof message !== "object" || message === null) return null;
+      const {
+        message_id: messageId,
+        message_thread_id: threadId,
+        text,
+        chat,
+        from
+      } = message;
+      if (from?.is_bot === true) return null;
+      if (typeof threadId !== "number") return null;
+      if (typeof messageId !== "number") return null;
+      if (typeof text !== "string" || text.trim().length === 0) return null;
+      if (!chatId || String(chat?.id) !== chatId) return null;
+      return { threadId, text, messageId };
+    },
+    verifyWebhook(request) {
+      const header = request.headers.get("x-telegram-bot-api-secret-token");
+      if (!header) return false;
+      return header === webhookSecret;
+    }
+  };
+}
+
+export { DEFAULT_CHAT_LIMITS, DEFAULT_CHAT_SERVER_COPY, MAX_NAME_LENGTH, TelegramError, buildTopicName, checkRateLimit, createChatServer, describeBrowser, getClientIp, hashIp, inMemoryStore, resolveConfig, sanitizeName, telegramTransport, upstashRedisStore };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map