@hasna/microservices 0.0.7 → 0.0.8

package/microservices/microservice-social/src/db/migrations.ts

@@ -85,4 +85,76 @@ export const MIGRATIONS: MigrationEntry[] = [
       CREATE INDEX IF NOT EXISTS idx_posts_recurrence ON posts(recurrence);
     `,
   },
+  {
+    id: 3,
+    name: "add_mentions",
+    sql: `
+      CREATE TABLE IF NOT EXISTS mentions (
+        id TEXT PRIMARY KEY,
+        account_id TEXT NOT NULL REFERENCES accounts(id) ON DELETE CASCADE,
+        platform TEXT NOT NULL,
+        author TEXT,
+        author_handle TEXT,
+        content TEXT,
+        type TEXT CHECK (type IN ('mention', 'reply', 'quote', 'dm')),
+        platform_post_id TEXT,
+        sentiment TEXT,
+        read INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT,
+        fetched_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_mentions_account ON mentions(account_id);
+      CREATE INDEX IF NOT EXISTS idx_mentions_read ON mentions(read);
+      CREATE INDEX IF NOT EXISTS idx_mentions_type ON mentions(type);
+    `,
+  },
+  {
+    id: 4,
+    name: "add_last_metrics_sync",
+    sql: `
+      ALTER TABLE posts ADD COLUMN last_metrics_sync TEXT;
+      CREATE INDEX IF NOT EXISTS idx_posts_last_metrics_sync ON posts(last_metrics_sync);
+    `,
+  },
+  {
+    id: 5,
+    name: "add_thread_support",
+    sql: `
+      ALTER TABLE posts ADD COLUMN thread_id TEXT;
+      ALTER TABLE posts ADD COLUMN thread_position INTEGER;
+      CREATE INDEX IF NOT EXISTS idx_posts_thread ON posts(thread_id);
+    `,
+  },
+  {
+    id: 6,
+    name: "add_followers_and_audience_snapshots",
+    sql: `
+      CREATE TABLE IF NOT EXISTS followers (
+        id TEXT PRIMARY KEY,
+        account_id TEXT NOT NULL,
+        platform_user_id TEXT,
+        username TEXT,
+        display_name TEXT,
+        follower_count INTEGER DEFAULT 0,
+        following INTEGER DEFAULT 1,
+        followed_at TEXT,
+        unfollowed_at TEXT,
+        metadata TEXT DEFAULT '{}',
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS audience_snapshots (
+        id TEXT PRIMARY KEY,
+        account_id TEXT NOT NULL,
+        follower_count INTEGER DEFAULT 0,
+        following_count INTEGER DEFAULT 0,
+        snapshot_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_followers_account ON followers(account_id);
+      CREATE INDEX IF NOT EXISTS idx_followers_following ON followers(following);
+      CREATE INDEX IF NOT EXISTS idx_snapshots_account ON audience_snapshots(account_id);
+    `,
+  },
 ];

package/microservices/microservice-social/src/db/social.ts

@@ -99,6 +99,8 @@ export interface Post {
   engagement: Engagement;
   tags: string[];
   recurrence: Recurrence | null;
+  thread_id: string | null;
+  thread_position: number | null;
   created_at: string;
   updated_at: string;
 }
@@ -115,6 +117,8 @@ interface PostRow {
   engagement: string;
   tags: string;
   recurrence: string | null;
+  thread_id: string | null;
+  thread_position: number | null;
   created_at: string;
   updated_at: string;
 }
@@ -127,6 +131,8 @@ function rowToPost(row: PostRow): Post {
     engagement: JSON.parse(row.engagement || "{}"),
     tags: JSON.parse(row.tags || "[]"),
     recurrence: (row.recurrence as Recurrence) || null,
+    thread_id: row.thread_id || null,
+    thread_position: row.thread_position ?? null,
   };
 }
 
@@ -299,6 +305,8 @@ export interface CreatePostInput {
   scheduled_at?: string;
   tags?: string[];
   recurrence?: Recurrence;
+  thread_id?: string;
+  thread_position?: number;
 }
 
 export function createPost(input: CreatePostInput): Post {
@@ -308,8 +316,8 @@ export function createPost(input: CreatePostInput): Post {
   const tags = JSON.stringify(input.tags || []);
 
   db.prepare(
-    `INSERT INTO posts (id, account_id, content, media_urls, status, scheduled_at, tags, recurrence)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    `INSERT INTO posts (id, account_id, content, media_urls, status, scheduled_at, tags, recurrence, thread_id, thread_position)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
   ).run(
     id,
     input.account_id,
@@ -318,7 +326,9 @@ export function createPost(input: CreatePostInput): Post {
     input.status || "draft",
     input.scheduled_at || null,
     tags,
-    input.recurrence || null
+    input.recurrence || null,
+    input.thread_id || null,
+    input.thread_position ?? null
   );
 
   return getPost(id)!;
@@ -462,6 +472,26 @@ export function countPosts(): number {
   return row.count;
 }
 
+/**
+ * Get all posts in a thread, ordered by thread_position
+ */
+export function getThreadPosts(threadId: string): Post[] {
+  const db = getDatabase();
+  const rows = db.prepare(
+    "SELECT * FROM posts WHERE thread_id = ? ORDER BY thread_position ASC"
+  ).all(threadId) as PostRow[];
+  return rows.map(rowToPost);
+}
+
+/**
+ * Delete all posts in a thread
+ */
+export function deleteThreadPosts(threadId: string): number {
+  const db = getDatabase();
+  const result = db.prepare("DELETE FROM posts WHERE thread_id = ?").run(threadId);
+  return result.changes;
+}
+
 /**
  * Schedule a post — sets status to 'scheduled' and sets scheduled_at
  */

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

@@ -0,0 +1,353 @@
+/**
+ * Follower sync and audience insights
+ */
+
+import { getDatabase } from "../db/database.js";
+
+// ---- Types ----
+
+export interface Follower {
+  id: string;
+  account_id: string;
+  platform_user_id: string | null;
+  username: string | null;
+  display_name: string | null;
+  follower_count: number;
+  following: boolean;
+  followed_at: string | null;
+  unfollowed_at: string | null;
+  metadata: Record<string, unknown>;
+  created_at: string;
+}
+
+interface FollowerRow {
+  id: string;
+  account_id: string;
+  platform_user_id: string | null;
+  username: string | null;
+  display_name: string | null;
+  follower_count: number;
+  following: number;
+  followed_at: string | null;
+  unfollowed_at: string | null;
+  metadata: string;
+  created_at: string;
+}
+
+function rowToFollower(row: FollowerRow): Follower {
+  return {
+    ...row,
+    following: row.following === 1,
+    metadata: JSON.parse(row.metadata || "{}"),
+  };
+}
+
+export interface AudienceSnapshot {
+  id: string;
+  account_id: string;
+  follower_count: number;
+  following_count: number;
+  snapshot_at: string;
+}
+
+export interface CreateFollowerInput {
+  account_id: string;
+  platform_user_id?: string;
+  username?: string;
+  display_name?: string;
+  follower_count?: number;
+  following?: boolean;
+  followed_at?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ListFollowersFilters {
+  following?: boolean;
+  search?: string;
+  limit?: number;
+  offset?: number;
+}
+
+export interface UpdateFollowerInput {
+  username?: string;
+  display_name?: string;
+  follower_count?: number;
+  following?: boolean;
+  unfollowed_at?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface AudienceInsights {
+  total_followers: number;
+  growth_rate_7d: number;
+  growth_rate_30d: number;
+  new_followers_7d: number;
+  lost_followers_7d: number;
+  top_followers: Follower[];
+}
+
+export interface GrowthPoint {
+  date: string;
+  count: number;
+}
+
+// ---- Followers CRUD ----
+
+export function createFollower(input: CreateFollowerInput): Follower {
+  const db = getDatabase();
+  const id = crypto.randomUUID();
+  const metadata = JSON.stringify(input.metadata || {});
+
+  db.prepare(
+    `INSERT INTO followers (id, account_id, platform_user_id, username, display_name, follower_count, following, followed_at, metadata)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    input.account_id,
+    input.platform_user_id || null,
+    input.username || null,
+    input.display_name || null,
+    input.follower_count ?? 0,
+    input.following !== false ? 1 : 0,
+    input.followed_at || null,
+    metadata
+  );
+
+  return getFollower(id)!;
+}
+
+export function getFollower(id: string): Follower | null {
+  const db = getDatabase();
+  const row = db.prepare("SELECT * FROM followers WHERE id = ?").get(id) as FollowerRow | null;
+  return row ? rowToFollower(row) : null;
+}
+
+export function listFollowers(accountId: string, filters: ListFollowersFilters = {}): Follower[] {
+  const db = getDatabase();
+  const conditions: string[] = ["account_id = ?"];
+  const params: unknown[] = [accountId];
+
+  if (filters.following !== undefined) {
+    conditions.push("following = ?");
+    params.push(filters.following ? 1 : 0);
+  }
+
+  if (filters.search) {
+    conditions.push("(username LIKE ? OR display_name LIKE ?)");
+    params.push(`%${filters.search}%`, `%${filters.search}%`);
+  }
+
+  let sql = `SELECT * FROM followers WHERE ${conditions.join(" AND ")} ORDER BY follower_count 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 FollowerRow[];
+  return rows.map(rowToFollower);
+}
+
+export function updateFollower(id: string, input: UpdateFollowerInput): Follower | null {
+  const db = getDatabase();
+  const existing = getFollower(id);
+  if (!existing) return null;
+
+  const sets: string[] = [];
+  const params: unknown[] = [];
+
+  if (input.username !== undefined) {
+    sets.push("username = ?");
+    params.push(input.username);
+  }
+  if (input.display_name !== undefined) {
+    sets.push("display_name = ?");
+    params.push(input.display_name);
+  }
+  if (input.follower_count !== undefined) {
+    sets.push("follower_count = ?");
+    params.push(input.follower_count);
+  }
+  if (input.following !== undefined) {
+    sets.push("following = ?");
+    params.push(input.following ? 1 : 0);
+  }
+  if (input.unfollowed_at !== undefined) {
+    sets.push("unfollowed_at = ?");
+    params.push(input.unfollowed_at);
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+
+  if (sets.length === 0) return existing;
+
+  params.push(id);
+  db.prepare(`UPDATE followers SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+
+  return getFollower(id);
+}
+
+export function removeFollower(id: string): boolean {
+  const db = getDatabase();
+  const result = db.prepare("DELETE FROM followers WHERE id = ?").run(id);
+  return result.changes > 0;
+}
+
+// ---- Sync ----
+
+export interface SyncResult {
+  synced: number;
+  new_followers: number;
+  unfollowed: number;
+  message: string;
+}
+
+/**
+ * Stub that would call the platform API for follower list, upsert into DB.
+ * In production this would call X/Instagram/LinkedIn APIs.
+ */
+export function syncFollowers(accountId: string): SyncResult {
+  // In a real implementation, this would:
+  // 1. Call the platform API to get the current follower list
+  // 2. Upsert new followers into the DB
+  // 3. Mark unfollowed users (following=0, set unfollowed_at)
+  // 4. Update follower metadata (display_name, follower_count)
+
+  const db = getDatabase();
+  const currentFollowers = db.prepare(
+    "SELECT COUNT(*) as count FROM followers WHERE account_id = ? AND following = 1"
+  ).get(accountId) as { count: number };
+
+  return {
+    synced: currentFollowers.count,
+    new_followers: 0,
+    unfollowed: 0,
+    message: "Sync stub — connect platform API credentials to enable live sync.",
+  };
+}
+
+// ---- Snapshots ----
+
+export function createSnapshot(
+  accountId: string,
+  followerCount: number,
+  followingCount: number
+): AudienceSnapshot {
+  const db = getDatabase();
+  const id = crypto.randomUUID();
+
+  db.prepare(
+    `INSERT INTO audience_snapshots (id, account_id, follower_count, following_count)
+     VALUES (?, ?, ?, ?)`
+  ).run(id, accountId, followerCount, followingCount);
+
+  return db.prepare("SELECT * FROM audience_snapshots WHERE id = ?").get(id) as AudienceSnapshot;
+}
+
+/**
+ * Creates a daily snapshot from current follower counts in the DB.
+ */
+export function trackGrowth(accountId: string): AudienceSnapshot {
+  const db = getDatabase();
+
+  const followerCount = (
+    db.prepare(
+      "SELECT COUNT(*) as count FROM followers WHERE account_id = ? AND following = 1"
+    ).get(accountId) as { count: number }
+  ).count;
+
+  const followingCount = (
+    db.prepare(
+      "SELECT COUNT(*) as count FROM followers WHERE account_id = ? AND following = 0"
+    ).get(accountId) as { count: number }
+  ).count;
+
+  return createSnapshot(accountId, followerCount, followingCount);
+}
+
+// ---- Insights ----
+
+export function getAudienceInsights(accountId: string): AudienceInsights {
+  const db = getDatabase();
+
+  // Total current followers
+  const total_followers = (
+    db.prepare(
+      "SELECT COUNT(*) as count FROM followers WHERE account_id = ? AND following = 1"
+    ).get(accountId) as { count: number }
+  ).count;
+
+  // New followers in last 7 days
+  const new_followers_7d = (
+    db.prepare(
+      "SELECT COUNT(*) as count FROM followers WHERE account_id = ? AND following = 1 AND created_at >= datetime('now', '-7 days')"
+    ).get(accountId) as { count: number }
+  ).count;
+
+  // Lost followers in last 7 days
+  const lost_followers_7d = (
+    db.prepare(
+      "SELECT COUNT(*) as count FROM followers WHERE account_id = ? AND following = 0 AND unfollowed_at >= datetime('now', '-7 days')"
+    ).get(accountId) as { count: number }
+  ).count;
+
+  // Growth rates from snapshots
+  const growth_rate_7d = calculateGrowthRate(accountId, 7);
+  const growth_rate_30d = calculateGrowthRate(accountId, 30);
+
+  // Top followers by their follower count
+  const top_followers = listFollowers(accountId, { following: true, limit: 10 });
+
+  return {
+    total_followers,
+    growth_rate_7d,
+    growth_rate_30d,
+    new_followers_7d,
+    lost_followers_7d,
+    top_followers,
+  };
+}
+
+function calculateGrowthRate(accountId: string, days: number): number {
+  const db = getDatabase();
+
+  const latest = db.prepare(
+    "SELECT follower_count FROM audience_snapshots WHERE account_id = ? ORDER BY snapshot_at DESC LIMIT 1"
+  ).get(accountId) as { follower_count: number } | null;
+
+  const older = db.prepare(
+    `SELECT follower_count FROM audience_snapshots WHERE account_id = ? AND snapshot_at <= datetime('now', '-${days} days') ORDER BY snapshot_at DESC LIMIT 1`
+  ).get(accountId) as { follower_count: number } | null;
+
+  if (!latest || !older || older.follower_count === 0) return 0;
+
+  return Math.round(((latest.follower_count - older.follower_count) / older.follower_count) * 10000) / 100;
+}
+
+// ---- Growth Chart ----
+
+export function getFollowerGrowthChart(accountId: string, days: number = 30): GrowthPoint[] {
+  const db = getDatabase();
+
+  const rows = db.prepare(
+    `SELECT date(snapshot_at) as date, MAX(follower_count) as count
+     FROM audience_snapshots
+     WHERE account_id = ? AND snapshot_at >= datetime('now', '-${days} days')
+     GROUP BY date(snapshot_at)
+     ORDER BY date ASC`
+  ).all(accountId) as GrowthPoint[];
+
+  return rows;
+}
+
+// ---- Top Followers ----
+
+export function getTopFollowers(accountId: string, limit: number = 10): Follower[] {
+  return listFollowers(accountId, { following: true, limit });
+}