@hasna/microservices 0.0.16 → 0.0.17

package/microservices/microservice-social/src/lib/mentions.ts

@@ -1,434 +0,0 @@
-/**
- * Mention monitoring — searches platform APIs for @handle mentions,
- * stores them locally, and provides reply/read/stats operations.
- */
-
-import { getDatabase } from "../db/database.js";
-import { getAccount, listAccounts, type Platform } from "../db/social.js";
-
-// ---- Types ----
-
-export type MentionType = "mention" | "reply" | "quote" | "dm";
-
-export interface Mention {
-  id: string;
-  account_id: string;
-  platform: string;
-  author: string | null;
-  author_handle: string | null;
-  content: string | null;
-  type: MentionType | null;
-  platform_post_id: string | null;
-  sentiment: string | null;
-  read: boolean;
-  created_at: string | null;
-  fetched_at: string;
-}
-
-interface MentionRow {
-  id: string;
-  account_id: string;
-  platform: string;
-  author: string | null;
-  author_handle: string | null;
-  content: string | null;
-  type: string | null;
-  platform_post_id: string | null;
-  sentiment: string | null;
-  read: number;
-  created_at: string | null;
-  fetched_at: string;
-}
-
-function rowToMention(row: MentionRow): Mention {
-  return {
-    ...row,
-    type: (row.type as MentionType) || null,
-    read: row.read === 1,
-  };
-}
-
-// ---- CRUD ----
-
-export interface CreateMentionInput {
-  account_id: string;
-  platform: string;
-  author?: string;
-  author_handle?: string;
-  content?: string;
-  type?: MentionType;
-  platform_post_id?: string;
-  sentiment?: string;
-  created_at?: string;
-}
-
-export function createMention(input: CreateMentionInput): Mention {
-  const db = getDatabase();
-  const id = crypto.randomUUID();
-
-  db.prepare(
-    `INSERT INTO mentions (id, account_id, platform, author, author_handle, content, type, platform_post_id, sentiment, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  ).run(
-    id,
-    input.account_id,
-    input.platform,
-    input.author || null,
-    input.author_handle || null,
-    input.content || null,
-    input.type || null,
-    input.platform_post_id || null,
-    input.sentiment || null,
-    input.created_at || null
-  );
-
-  return getMention(id)!;
-}
-
-export function getMention(id: string): Mention | null {
-  const db = getDatabase();
-  const row = db.prepare("SELECT * FROM mentions WHERE id = ?").get(id) as MentionRow | null;
-  return row ? rowToMention(row) : null;
-}
-
-export interface ListMentionsOptions {
-  account_id?: string;
-  unread?: boolean;
-  type?: MentionType;
-  platform?: string;
-  limit?: number;
-  offset?: number;
-}
-
-export function listMentions(accountId?: string, filters: Omit<ListMentionsOptions, "account_id"> = {}): Mention[] {
-  const db = getDatabase();
-  const conditions: string[] = [];
-  const params: unknown[] = [];
-
-  if (accountId) {
-    conditions.push("account_id = ?");
-    params.push(accountId);
-  }
-
-  if (filters.unread !== undefined) {
-    conditions.push("read = ?");
-    params.push(filters.unread ? 0 : 1);
-  }
-
-  if (filters.type) {
-    conditions.push("type = ?");
-    params.push(filters.type);
-  }
-
-  if (filters.platform) {
-    conditions.push("platform = ?");
-    params.push(filters.platform);
-  }
-
-  let sql = "SELECT * FROM mentions";
-  if (conditions.length > 0) {
-    sql += " WHERE " + conditions.join(" AND ");
-  }
-  sql += " ORDER BY fetched_at DESC";
-
-  if (filters.limit) {
-    sql += " LIMIT ?";
-    params.push(filters.limit);
-  }
-  if (filters.offset) {
-    sql += " OFFSET ?";
-    params.push(filters.offset);
-  }
-
-  const rows = db.prepare(sql).all(...params) as MentionRow[];
-  return rows.map(rowToMention);
-}
-
-export function markRead(id: string): Mention | null {
-  const db = getDatabase();
-  const existing = getMention(id);
-  if (!existing) return null;
-
-  db.prepare("UPDATE mentions SET read = 1 WHERE id = ?").run(id);
-  return getMention(id);
-}
-
-export function markAllRead(accountId: string): number {
-  const db = getDatabase();
-  const result = db.prepare("UPDATE mentions SET read = 1 WHERE account_id = ? AND read = 0").run(accountId);
-  return result.changes;
-}
-
-// ---- Stats ----
-
-export interface MentionStats {
-  total: number;
-  unread: number;
-  by_type: Record<string, number>;
-  by_sentiment: Record<string, number>;
-}
-
-export function getMentionStats(accountId: string): MentionStats {
-  const db = getDatabase();
-
-  const totalRow = db.prepare("SELECT COUNT(*) as count FROM mentions WHERE account_id = ?").get(accountId) as { count: number };
-  const unreadRow = db.prepare("SELECT COUNT(*) as count FROM mentions WHERE account_id = ? AND read = 0").get(accountId) as { count: number };
-
-  const typeRows = db.prepare(
-    "SELECT type, COUNT(*) as count FROM mentions WHERE account_id = ? AND type IS NOT NULL GROUP BY type"
-  ).all(accountId) as { type: string; count: number }[];
-
-  const sentimentRows = db.prepare(
-    "SELECT sentiment, COUNT(*) as count FROM mentions WHERE account_id = ? AND sentiment IS NOT NULL GROUP BY sentiment"
-  ).all(accountId) as { sentiment: string; count: number }[];
-
-  const by_type: Record<string, number> = {};
-  for (const row of typeRows) {
-    by_type[row.type] = row.count;
-  }
-
-  const by_sentiment: Record<string, number> = {};
-  for (const row of sentimentRows) {
-    by_sentiment[row.sentiment] = row.count;
-  }
-
-  return {
-    total: totalRow.count,
-    unread: unreadRow.count,
-    by_type,
-    by_sentiment,
-  };
-}
-
-// ---- Platform API search ----
-
-/**
- * Search for @handle mentions on a platform via its API.
- * X: GET /2/tweets/search/recent?query=@handle
- * Meta: GET /{page-id}/tagged
- *
- * Returns raw mention data that can be stored with createMention().
- */
-export async function searchMentions(accountId: string): Promise<CreateMentionInput[]> {
-  const account = getAccount(accountId);
-  if (!account) throw new Error(`Account '${accountId}' not found.`);
-
-  if (account.platform === "x") {
-    return searchXMentions(account.id, account.handle);
-  } else if (account.platform === "instagram") {
-    return searchMetaMentions(account.id, account.platform);
-  }
-
-  throw new Error(`Mention search not supported for platform '${account.platform}'.`);
-}
-
-async function searchXMentions(accountId: string, handle: string): Promise<CreateMentionInput[]> {
-  const bearerToken = process.env.X_BEARER_TOKEN || process.env.X_ACCESS_TOKEN;
-  if (!bearerToken) throw new Error("X API: no bearer token configured. Set X_BEARER_TOKEN.");
-
-  const query = encodeURIComponent(`@${handle}`);
-  const res = await fetch(
-    `https://api.twitter.com/2/tweets/search/recent?query=${query}&tweet.fields=author_id,created_at,in_reply_to_user_id&expansions=author_id&user.fields=name,username`,
-    {
-      headers: { Authorization: `Bearer ${bearerToken}` },
-    }
-  );
-
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`X API error ${res.status}: ${text}`);
-  }
-
-  const data = (await res.json()) as {
-    data?: { id: string; text: string; author_id: string; created_at?: string; in_reply_to_user_id?: string }[];
-    includes?: { users?: { id: string; name: string; username: string }[] };
-  };
-
-  if (!data.data) return [];
-
-  const userMap = new Map<string, { name: string; username: string }>();
-  if (data.includes?.users) {
-    for (const u of data.includes.users) {
-      userMap.set(u.id, { name: u.name, username: u.username });
-    }
-  }
-
-  return data.data.map((tweet) => {
-    const user = userMap.get(tweet.author_id);
-    const mentionType: MentionType = tweet.in_reply_to_user_id ? "reply" : "mention";
-
-    return {
-      account_id: accountId,
-      platform: "x",
-      author: user?.name || null,
-      author_handle: user?.username || null,
-      content: tweet.text,
-      type: mentionType,
-      platform_post_id: tweet.id,
-      created_at: tweet.created_at || null,
-    } as CreateMentionInput;
-  });
-}
-
-async function searchMetaMentions(accountId: string, platform: string): Promise<CreateMentionInput[]> {
-  const accessToken = process.env.META_ACCESS_TOKEN;
-  const pageId = process.env.META_PAGE_ID;
-  if (!accessToken || !pageId) throw new Error("Meta API: META_ACCESS_TOKEN and META_PAGE_ID required.");
-
-  const res = await fetch(
-    `https://graph.facebook.com/v22.0/${pageId}/tagged?access_token=${encodeURIComponent(accessToken)}&fields=id,message,from,created_time`,
-    { method: "GET" }
-  );
-
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Meta API error ${res.status}: ${text}`);
-  }
-
-  const data = (await res.json()) as {
-    data?: { id: string; message?: string; from?: { name: string; id: string }; created_time?: string }[];
-  };
-
-  if (!data.data) return [];
-
-  return data.data.map((post) => ({
-    account_id: accountId,
-    platform,
-    author: post.from?.name || null,
-    author_handle: post.from?.id || null,
-    content: post.message || null,
-    type: "mention" as MentionType,
-    platform_post_id: post.id,
-    created_at: post.created_time || null,
-  }));
-}
-
-// ---- Reply ----
-
-/**
- * Reply to a mention via the platform API.
- * X: POST /2/tweets with in_reply_to_tweet_id
- * Meta: POST /{post-id}/comments
- */
-export async function replyToMention(mentionId: string, content: string): Promise<{ platformReplyId: string }> {
-  const mention = getMention(mentionId);
-  if (!mention) throw new Error(`Mention '${mentionId}' not found.`);
-  if (!mention.platform_post_id) throw new Error(`Mention '${mentionId}' has no platform_post_id to reply to.`);
-
-  const account = getAccount(mention.account_id);
-  if (!account) throw new Error(`Account '${mention.account_id}' not found.`);
-
-  if (mention.platform === "x") {
-    return replyOnX(mention.platform_post_id, content);
-  } else if (mention.platform === "instagram" || mention.platform === "facebook") {
-    return replyOnMeta(mention.platform_post_id, content);
-  }
-
-  throw new Error(`Reply not supported for platform '${mention.platform}'.`);
-}
-
-async function replyOnX(inReplyToId: string, content: string): Promise<{ platformReplyId: string }> {
-  const bearerToken = process.env.X_BEARER_TOKEN || process.env.X_ACCESS_TOKEN;
-  if (!bearerToken) throw new Error("X API: no bearer token configured.");
-
-  const res = await fetch("https://api.twitter.com/2/tweets", {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${bearerToken}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({
-      text: content,
-      reply: { in_reply_to_tweet_id: inReplyToId },
-    }),
-  });
-
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`X API error ${res.status}: ${text}`);
-  }
-
-  const data = (await res.json()) as { data: { id: string } };
-  return { platformReplyId: data.data.id };
-}
-
-async function replyOnMeta(postId: string, content: string): Promise<{ platformReplyId: string }> {
-  const accessToken = process.env.META_ACCESS_TOKEN;
-  if (!accessToken) throw new Error("Meta API: META_ACCESS_TOKEN required.");
-
-  const res = await fetch(
-    `https://graph.facebook.com/v22.0/${postId}/comments?access_token=${encodeURIComponent(accessToken)}`,
-    {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ message: content }),
-    }
-  );
-
-  if (!res.ok) {
-    const text = await res.text();
-    throw new Error(`Meta API error ${res.status}: ${text}`);
-  }
-
-  const data = (await res.json()) as { id: string };
-  return { platformReplyId: data.id };
-}
-
-// ---- Polling ----
-
-let _pollTimer: ReturnType<typeof setInterval> | null = null;
-let _pollRunning = false;
-
-/**
- * Start a background poller that periodically fetches new mentions for all
- * connected accounts and inserts them into the DB (deduped by platform_post_id).
- */
-export function pollMentions(intervalMs = 120000): void {
-  if (_pollRunning) throw new Error("Mention poller is already running.");
-
-  _pollRunning = true;
-
-  // Run immediately, then on interval
-  _runPollCycle();
-  _pollTimer = setInterval(_runPollCycle, intervalMs);
-}
-
-export function stopPolling(): void {
-  if (_pollTimer) {
-    clearInterval(_pollTimer);
-    _pollTimer = null;
-  }
-  _pollRunning = false;
-}
-
-export function isPolling(): boolean {
-  return _pollRunning;
-}
-
-async function _runPollCycle(): Promise<void> {
-  const accounts = listAccounts({ connected: true });
-
-  for (const account of accounts) {
-    try {
-      // Only poll platforms that support mention search
-      if (account.platform !== "x" && account.platform !== "instagram") continue;
-
-      const mentions = await searchMentions(account.id);
-
-      for (const m of mentions) {
-        // Dedup: skip if platform_post_id already exists
-        if (m.platform_post_id) {
-          const db = getDatabase();
-          const existing = db.prepare(
-            "SELECT id FROM mentions WHERE account_id = ? AND platform_post_id = ?"
-          ).get(account.id, m.platform_post_id);
-          if (existing) continue;
-        }
-
-        createMention(m);
-      }
-    } catch (_err) {
-      // Silently continue — poll cycle errors should not crash the poller
-    }
-  }
-}

package/microservices/microservice-social/src/lib/metrics-sync.ts

@@ -1,264 +0,0 @@
-/**
- * Metrics sync worker — pulls engagement data from platform APIs
- * for published posts and account follower counts.
- *
- * Uses publisher.syncPostMetrics() under the hood for individual posts,
- * and wraps it in a polling loop with error tracking.
- */
-
-import {
-  listPosts,
-  listAccounts,
-  getAccount,
-  updateAccount,
-  updatePost,
-  type Post,
-  type Account,
-} from "../db/social.js";
-import { getDatabase } from "../db/database.js";
-
-// ---- Types ----
-
-export interface SyncReport {
-  posts_synced: number;
-  accounts_synced: number;
-  last_sync: string | null;
-  errors: SyncError[];
-}
-
-export interface SyncError {
-  type: "post" | "account";
-  id: string;
-  message: string;
-  timestamp: string;
-}
-
-export interface MetricsSyncStatus {
-  running: boolean;
-  interval_ms: number;
-  last_sync: string | null;
-  posts_synced: number;
-  accounts_synced: number;
-  errors: number;
-}
-
-// ---- State ----
-
-let _interval: ReturnType<typeof setInterval> | null = null;
-let _status: MetricsSyncStatus = {
-  running: false,
-  interval_ms: 0,
-  last_sync: null,
-  posts_synced: 0,
-  accounts_synced: 0,
-  errors: 0,
-};
-let _errors: SyncError[] = [];
-
-// ---- Core Functions ----
-
-/**
- * Get published posts from the last N days that need metrics sync.
- */
-export function getRecentPublishedPosts(days: number = 7): Post[] {
-  const cutoff = new Date();
-  cutoff.setDate(cutoff.getDate() - days);
-  const cutoffStr = cutoff.toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
-
-  const db = getDatabase();
-  const rows = db
-    .prepare(
-      `SELECT * FROM posts
-       WHERE status = 'published'
-         AND published_at IS NOT NULL
-         AND published_at >= ?
-         AND platform_post_id IS NOT NULL
-       ORDER BY published_at DESC`
-    )
-    .all(cutoffStr) as Array<{
-      id: string;
-      account_id: string;
-      content: string;
-      media_urls: string;
-      status: string;
-      scheduled_at: string | null;
-      published_at: string | null;
-      platform_post_id: string | null;
-      engagement: string;
-      tags: string;
-      recurrence: string | null;
-      last_metrics_sync: string | null;
-      created_at: string;
-      updated_at: string;
-    }>;
-
-  return rows.map((row) => ({
-    id: row.id,
-    account_id: row.account_id,
-    content: row.content,
-    media_urls: JSON.parse(row.media_urls || "[]"),
-    status: row.status as Post["status"],
-    scheduled_at: row.scheduled_at,
-    published_at: row.published_at,
-    platform_post_id: row.platform_post_id,
-    engagement: JSON.parse(row.engagement || "{}"),
-    tags: JSON.parse(row.tags || "[]"),
-    recurrence: (row.recurrence as Post["recurrence"]) || null,
-    created_at: row.created_at,
-    updated_at: row.updated_at,
-  }));
-}
-
-/**
- * Sync metrics for all published posts from the last 7 days.
- * Calls publisher.syncPostMetrics(postId) for each post.
- */
-export async function syncAllMetrics(): Promise<SyncReport> {
-  const posts = getRecentPublishedPosts(7);
-  const errors: SyncError[] = [];
-  let posts_synced = 0;
-
-  for (const post of posts) {
-    try {
-      const { syncPostMetrics } = await import("./publisher.js");
-      await syncPostMetrics(post.id);
-
-      // Update last_metrics_sync timestamp
-      const db = getDatabase();
-      const now = new Date().toISOString().replace("T", " ").replace(/\.\d+Z$/, "");
-      db.prepare("UPDATE posts SET last_metrics_sync = ? WHERE id = ?").run(now, post.id);
-
-      posts_synced++;
-    } catch (err) {
-      const error: SyncError = {
-        type: "post",
-        id: post.id,
-        message: err instanceof Error ? err.message : String(err),
-        timestamp: new Date().toISOString(),
-      };
-      errors.push(error);
-    }
-  }
-
-  const now = new Date().toISOString();
-  _status.posts_synced += posts_synced;
-  _status.errors += errors.length;
-  _status.last_sync = now;
-  _errors.push(...errors);
-
-  return {
-    posts_synced,
-    accounts_synced: 0,
-    last_sync: now,
-    errors,
-  };
-}
-
-/**
- * Pull follower count from platform API and store in account metadata.
- * Since we don't have a dedicated "get user profile" API call in the publisher
- * interface, we store a follower_count field in the account's metadata JSON.
- */
-export async function syncAccountMetrics(accountId: string): Promise<Account | null> {
-  const account = getAccount(accountId);
-  if (!account) return null;
-
-  try {
-    // Attempt to get publisher for this platform
-    const { getPublisher } = await import("./publisher.js");
-    const publisher = getPublisher(account.platform);
-
-    // The publisher interface doesn't expose a getUserProfile method,
-    // so we simulate by storing a sync timestamp in metadata.
-    // In a real implementation, each publisher would have a getProfile() method.
-    const metadata = {
-      ...account.metadata,
-      last_metrics_sync: new Date().toISOString(),
-    };
-
-    const updated = updateAccount(accountId, { metadata });
-    _status.accounts_synced++;
-    return updated;
-  } catch (err) {
-    const error: SyncError = {
-      type: "account",
-      id: accountId,
-      message: err instanceof Error ? err.message : String(err),
-      timestamp: new Date().toISOString(),
-    };
-    _errors.push(error);
-    _status.errors++;
-
-    // Still update metadata with error info
-    const metadata = {
-      ...account.metadata,
-      last_metrics_sync_error: err instanceof Error ? err.message : String(err),
-      last_metrics_sync_attempt: new Date().toISOString(),
-    };
-    return updateAccount(accountId, { metadata });
-  }
-}
-
-/**
- * Start the metrics sync polling loop.
- */
-export function startMetricsSync(intervalMs: number = 300000): void {
-  if (_interval) {
-    throw new Error("Metrics sync is already running. Stop it first.");
-  }
-
-  _status.running = true;
-  _status.interval_ms = intervalMs;
-
-  // Run immediately on start
-  syncAllMetrics().catch(() => {});
-
-  _interval = setInterval(() => {
-    syncAllMetrics().catch(() => {});
-  }, intervalMs);
-}
-
-/**
- * Stop the metrics sync polling loop.
- */
-export function stopMetricsSync(): void {
-  if (_interval) {
-    clearInterval(_interval);
-    _interval = null;
-  }
-  _status.running = false;
-}
-
-/**
- * Get the current metrics sync status.
- */
-export function getMetricsSyncStatus(): MetricsSyncStatus {
-  return { ..._status };
-}
-
-/**
- * Get a full sync report including recent errors.
- */
-export function getSyncReport(): SyncReport {
-  return {
-    posts_synced: _status.posts_synced,
-    accounts_synced: _status.accounts_synced,
-    last_sync: _status.last_sync,
-    errors: [..._errors],
-  };
-}
-
-/**
- * Reset metrics sync state (useful for testing).
- */
-export function resetMetricsSyncStatus(): void {
-  _status = {
-    running: _interval !== null,
-    interval_ms: _status.interval_ms,
-    last_sync: null,
-    posts_synced: 0,
-    accounts_synced: 0,
-    errors: 0,
-  };
-  _errors = [];
-}