@hasna/microservices 0.0.2 → 0.0.4

package/microservices/microservice-subscriptions/src/cli/index.ts

@@ -0,0 +1,400 @@
+#!/usr/bin/env bun
+
+import { Command } from "commander";
+import {
+  createPlan,
+  getPlan,
+  listPlans,
+  updatePlan,
+  deletePlan,
+  createSubscriber,
+  getSubscriber,
+  listSubscribers,
+  cancelSubscriber,
+  upgradeSubscriber,
+  downgradeSubscriber,
+  listEvents,
+  getMrr,
+  getArr,
+  getChurnRate,
+  listExpiring,
+  getSubscriberStats,
+} from "../db/subscriptions.js";
+
+const program = new Command();
+
+program
+  .name("microservice-subscriptions")
+  .description("Subscription and recurring billing management microservice")
+  .version("0.0.1");
+
+// --- Plans ---
+
+const planCmd = program
+  .command("plan")
+  .description("Plan management");
+
+planCmd
+  .command("create")
+  .description("Create a new plan")
+  .requiredOption("--name <name>", "Plan name")
+  .requiredOption("--price <price>", "Price")
+  .option("--interval <interval>", "Billing interval (monthly/yearly/lifetime)", "monthly")
+  .option("--features <features>", "Comma-separated features")
+  .option("--json", "Output as JSON", false)
+  .action((opts) => {
+    const plan = createPlan({
+      name: opts.name,
+      price: parseFloat(opts.price),
+      interval: opts.interval,
+      features: opts.features ? opts.features.split(",").map((f: string) => f.trim()) : undefined,
+    });
+
+    if (opts.json) {
+      console.log(JSON.stringify(plan, null, 2));
+    } else {
+      console.log(`Created plan: ${plan.name} — $${plan.price}/${plan.interval} (${plan.id})`);
+    }
+  });
+
+planCmd
+  .command("list")
+  .description("List plans")
+  .option("--active", "Show active plans only")
+  .option("--interval <interval>", "Filter by interval")
+  .option("--json", "Output as JSON", false)
+  .action((opts) => {
+    const plans = listPlans({
+      active_only: opts.active,
+      interval: opts.interval,
+    });
+
+    if (opts.json) {
+      console.log(JSON.stringify(plans, null, 2));
+    } else {
+      if (plans.length === 0) {
+        console.log("No plans found.");
+        return;
+      }
+      for (const p of plans) {
+        const status = p.active ? "" : " [inactive]";
+        console.log(`  ${p.name} — $${p.price}/${p.interval}${status} (${p.id})`);
+      }
+      console.log(`\n${plans.length} plan(s)`);
+    }
+  });
+
+planCmd
+  .command("get")
+  .description("Get a plan by ID")
+  .argument("<id>", "Plan ID")
+  .option("--json", "Output as JSON", false)
+  .action((id, opts) => {
+    const plan = getPlan(id);
+    if (!plan) {
+      console.error(`Plan '${id}' not found.`);
+      process.exit(1);
+    }
+
+    if (opts.json) {
+      console.log(JSON.stringify(plan, null, 2));
+    } else {
+      console.log(`${plan.name}`);
+      console.log(`  Price: $${plan.price}/${plan.interval}`);
+      console.log(`  Active: ${plan.active}`);
+      if (plan.features.length) console.log(`  Features: ${plan.features.join(", ")}`);
+    }
+  });
+
+planCmd
+  .command("update")
+  .description("Update a plan")
+  .argument("<id>", "Plan ID")
+  .option("--name <name>", "Plan name")
+  .option("--price <price>", "Price")
+  .option("--interval <interval>", "Billing interval")
+  .option("--features <features>", "Comma-separated features")
+  .option("--active <active>", "Active status (true/false)")
+  .option("--json", "Output as JSON", false)
+  .action((id, opts) => {
+    const input: Record<string, unknown> = {};
+    if (opts.name !== undefined) input.name = opts.name;
+    if (opts.price !== undefined) input.price = parseFloat(opts.price);
+    if (opts.interval !== undefined) input.interval = opts.interval;
+    if (opts.features !== undefined) input.features = opts.features.split(",").map((f: string) => f.trim());
+    if (opts.active !== undefined) input.active = opts.active === "true";
+
+    const plan = updatePlan(id, input);
+    if (!plan) {
+      console.error(`Plan '${id}' not found.`);
+      process.exit(1);
+    }
+
+    if (opts.json) {
+      console.log(JSON.stringify(plan, null, 2));
+    } else {
+      console.log(`Updated: ${plan.name} — $${plan.price}/${plan.interval}`);
+    }
+  });
+
+// --- Subscribers ---
+
+const subCmd = program
+  .command("subscriber")
+  .alias("sub")
+  .description("Subscriber management");
+
+subCmd
+  .command("add")
+  .description("Add a new subscriber")
+  .requiredOption("--plan <id>", "Plan ID")
+  .requiredOption("--name <name>", "Customer name")
+  .requiredOption("--email <email>", "Customer email")
+  .option("--status <status>", "Initial status", "active")
+  .option("--trial-ends <date>", "Trial end date (YYYY-MM-DD)")
+  .option("--json", "Output as JSON", false)
+  .action((opts) => {
+    const subscriber = createSubscriber({
+      plan_id: opts.plan,
+      customer_name: opts.name,
+      customer_email: opts.email,
+      status: opts.status,
+      trial_ends_at: opts.trialEnds,
+    });
+
+    if (opts.json) {
+      console.log(JSON.stringify(subscriber, null, 2));
+    } else {
+      console.log(`Added subscriber: ${subscriber.customer_name} <${subscriber.customer_email}> (${subscriber.id})`);
+    }
+  });
+
+subCmd
+  .command("list")
+  .description("List subscribers")
+  .option("--plan <id>", "Filter by plan ID")
+  .option("--status <status>", "Filter by status")
+  .option("--search <query>", "Search by name or email")
+  .option("--limit <n>", "Limit results")
+  .option("--json", "Output as JSON", false)
+  .action((opts) => {
+    const subscribers = listSubscribers({
+      plan_id: opts.plan,
+      status: opts.status,
+      search: opts.search,
+      limit: opts.limit ? parseInt(opts.limit) : undefined,
+    });
+
+    if (opts.json) {
+      console.log(JSON.stringify(subscribers, null, 2));
+    } else {
+      if (subscribers.length === 0) {
+        console.log("No subscribers found.");
+        return;
+      }
+      for (const s of subscribers) {
+        console.log(`  ${s.customer_name} <${s.customer_email}> — ${s.status} (${s.id})`);
+      }
+      console.log(`\n${subscribers.length} subscriber(s)`);
+    }
+  });
+
+subCmd
+  .command("get")
+  .description("Get a subscriber by ID")
+  .argument("<id>", "Subscriber ID")
+  .option("--json", "Output as JSON", false)
+  .action((id, opts) => {
+    const subscriber = getSubscriber(id);
+    if (!subscriber) {
+      console.error(`Subscriber '${id}' not found.`);
+      process.exit(1);
+    }
+
+    if (opts.json) {
+      console.log(JSON.stringify(subscriber, null, 2));
+    } else {
+      console.log(`${subscriber.customer_name} <${subscriber.customer_email}>`);
+      console.log(`  Status: ${subscriber.status}`);
+      console.log(`  Plan: ${subscriber.plan_id}`);
+      console.log(`  Period: ${subscriber.current_period_start} — ${subscriber.current_period_end || "N/A"}`);
+      if (subscriber.canceled_at) console.log(`  Canceled: ${subscriber.canceled_at}`);
+    }
+  });
+
+subCmd
+  .command("cancel")
+  .description("Cancel a subscription")
+  .argument("<id>", "Subscriber ID")
+  .option("--json", "Output as JSON", false)
+  .action((id, opts) => {
+    const subscriber = cancelSubscriber(id);
+    if (!subscriber) {
+      console.error(`Subscriber '${id}' not found.`);
+      process.exit(1);
+    }
+
+    if (opts.json) {
+      console.log(JSON.stringify(subscriber, null, 2));
+    } else {
+      console.log(`Canceled subscription for ${subscriber.customer_name}`);
+    }
+  });
+
+subCmd
+  .command("upgrade")
+  .description("Upgrade a subscriber to a new plan")
+  .argument("<id>", "Subscriber ID")
+  .requiredOption("--plan <id>", "New plan ID")
+  .option("--json", "Output as JSON", false)
+  .action((id, opts) => {
+    const subscriber = upgradeSubscriber(id, opts.plan);
+    if (!subscriber) {
+      console.error(`Subscriber '${id}' not found or plan not found.`);
+      process.exit(1);
+    }
+
+    if (opts.json) {
+      console.log(JSON.stringify(subscriber, null, 2));
+    } else {
+      console.log(`Upgraded ${subscriber.customer_name} to plan ${subscriber.plan_id}`);
+    }
+  });
+
+subCmd
+  .command("downgrade")
+  .description("Downgrade a subscriber to a new plan")
+  .argument("<id>", "Subscriber ID")
+  .requiredOption("--plan <id>", "New plan ID")
+  .option("--json", "Output as JSON", false)
+  .action((id, opts) => {
+    const subscriber = downgradeSubscriber(id, opts.plan);
+    if (!subscriber) {
+      console.error(`Subscriber '${id}' not found or plan not found.`);
+      process.exit(1);
+    }
+
+    if (opts.json) {
+      console.log(JSON.stringify(subscriber, null, 2));
+    } else {
+      console.log(`Downgraded ${subscriber.customer_name} to plan ${subscriber.plan_id}`);
+    }
+  });
+
+// --- Analytics ---
+
+program
+  .command("mrr")
+  .description("Get monthly recurring revenue")
+  .option("--json", "Output as JSON", false)
+  .action((opts) => {
+    const mrr = getMrr();
+    if (opts.json) {
+      console.log(JSON.stringify({ mrr }));
+    } else {
+      console.log(`MRR: $${mrr.toFixed(2)}`);
+    }
+  });
+
+program
+  .command("arr")
+  .description("Get annual recurring revenue")
+  .option("--json", "Output as JSON", false)
+  .action((opts) => {
+    const arr = getArr();
+    if (opts.json) {
+      console.log(JSON.stringify({ arr }));
+    } else {
+      console.log(`ARR: $${arr.toFixed(2)}`);
+    }
+  });
+
+program
+  .command("churn")
+  .description("Get churn rate")
+  .option("--period <days>", "Period in days", "30")
+  .option("--json", "Output as JSON", false)
+  .action((opts) => {
+    const rate = getChurnRate(parseInt(opts.period));
+    if (opts.json) {
+      console.log(JSON.stringify({ churn_rate: rate, period_days: parseInt(opts.period) }));
+    } else {
+      console.log(`Churn rate (${opts.period}d): ${rate}%`);
+    }
+  });
+
+program
+  .command("events")
+  .description("List subscription events")
+  .option("--subscriber <id>", "Filter by subscriber ID")
+  .option("--type <type>", "Filter by event type")
+  .option("--limit <n>", "Limit results", "20")
+  .option("--json", "Output as JSON", false)
+  .action((opts) => {
+    const events = listEvents({
+      subscriber_id: opts.subscriber,
+      type: opts.type,
+      limit: parseInt(opts.limit),
+    });
+
+    if (opts.json) {
+      console.log(JSON.stringify(events, null, 2));
+    } else {
+      if (events.length === 0) {
+        console.log("No events found.");
+        return;
+      }
+      for (const e of events) {
+        console.log(`  [${e.occurred_at}] ${e.type} — subscriber: ${e.subscriber_id}`);
+      }
+      console.log(`\n${events.length} event(s)`);
+    }
+  });
+
+program
+  .command("expiring")
+  .description("List subscriptions expiring soon")
+  .option("--days <days>", "Days ahead to check", "7")
+  .option("--json", "Output as JSON", false)
+  .action((opts) => {
+    const expiring = listExpiring(parseInt(opts.days));
+
+    if (opts.json) {
+      console.log(JSON.stringify(expiring, null, 2));
+    } else {
+      if (expiring.length === 0) {
+        console.log(`No subscriptions expiring in the next ${opts.days} days.`);
+        return;
+      }
+      for (const s of expiring) {
+        console.log(`  ${s.customer_name} <${s.customer_email}> — expires ${s.current_period_end}`);
+      }
+      console.log(`\n${expiring.length} expiring subscription(s)`);
+    }
+  });
+
+program
+  .command("stats")
+  .description("Get subscriber statistics")
+  .option("--json", "Output as JSON", false)
+  .action((opts) => {
+    const stats = getSubscriberStats();
+    const mrr = getMrr();
+    const arr = getArr();
+
+    if (opts.json) {
+      console.log(JSON.stringify({ ...stats, mrr, arr }, null, 2));
+    } else {
+      console.log("Subscriber Statistics:");
+      console.log(`  Total: ${stats.total}`);
+      console.log(`  Active: ${stats.active}`);
+      console.log(`  Trialing: ${stats.trialing}`);
+      console.log(`  Past Due: ${stats.past_due}`);
+      console.log(`  Canceled: ${stats.canceled}`);
+      console.log(`  Expired: ${stats.expired}`);
+      console.log(`  MRR: $${mrr.toFixed(2)}`);
+      console.log(`  ARR: $${arr.toFixed(2)}`);
+    }
+  });
+
+program.parse(process.argv);

package/microservices/microservice-subscriptions/src/db/database.ts

@@ -0,0 +1,93 @@
+/**
+ * Database connection for microservice-subscriptions
+ */
+
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { MIGRATIONS } from "./migrations.js";
+
+let _db: Database | null = null;
+
+function getDbPath(): string {
+  // Environment variable override
+  if (process.env["MICROSERVICES_DIR"]) {
+    return join(process.env["MICROSERVICES_DIR"], "microservice-subscriptions", "data.db");
+  }
+
+  // Check for .microservices in current or parent directories
+  let dir = resolve(process.cwd());
+  while (true) {
+    const candidate = join(dir, ".microservices", "microservice-subscriptions", "data.db");
+    const msDir = join(dir, ".microservices");
+    if (existsSync(msDir)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+
+  // Global fallback
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  return join(home, ".microservices", "microservice-subscriptions", "data.db");
+}
+
+function ensureDir(filePath: string): void {
+  const dir = dirname(resolve(filePath));
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+export function getDatabase(): Database {
+  if (_db) return _db;
+
+  const dbPath = getDbPath();
+  ensureDir(dbPath);
+
+  _db = new Database(dbPath);
+  _db.exec("PRAGMA journal_mode = WAL");
+  _db.exec("PRAGMA foreign_keys = ON");
+
+  // Create migrations table
+  _db.exec(`
+    CREATE TABLE IF NOT EXISTS _migrations (
+      id INTEGER PRIMARY KEY,
+      name TEXT NOT NULL,
+      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+
+  // Apply pending migrations
+  const applied = _db
+    .query("SELECT id FROM _migrations ORDER BY id")
+    .all() as { id: number }[];
+  const appliedIds = new Set(applied.map((r) => r.id));
+
+  for (const migration of MIGRATIONS) {
+    if (appliedIds.has(migration.id)) continue;
+
+    _db.exec("BEGIN");
+    try {
+      _db.exec(migration.sql);
+      _db.prepare("INSERT INTO _migrations (id, name) VALUES (?, ?)").run(
+        migration.id,
+        migration.name
+      );
+      _db.exec("COMMIT");
+    } catch (error) {
+      _db.exec("ROLLBACK");
+      throw new Error(
+        `Migration ${migration.id} (${migration.name}) failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
+  return _db;
+}
+
+export function closeDatabase(): void {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}

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

@@ -0,0 +1,57 @@
+export interface MigrationEntry {
+  id: number;
+  name: string;
+  sql: string;
+}
+
+export const MIGRATIONS: MigrationEntry[] = [
+  {
+    id: 1,
+    name: "initial_schema",
+    sql: `
+      CREATE TABLE IF NOT EXISTS plans (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        price REAL NOT NULL DEFAULT 0,
+        interval TEXT NOT NULL DEFAULT 'monthly' CHECK (interval IN ('monthly', 'yearly', 'lifetime')),
+        features TEXT NOT NULL DEFAULT '[]',
+        active INTEGER NOT NULL DEFAULT 1,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS subscribers (
+        id TEXT PRIMARY KEY,
+        plan_id TEXT NOT NULL REFERENCES plans(id) ON DELETE RESTRICT,
+        customer_name TEXT NOT NULL,
+        customer_email TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('trialing', 'active', 'past_due', 'canceled', 'expired')),
+        started_at TEXT NOT NULL DEFAULT (datetime('now')),
+        trial_ends_at TEXT,
+        current_period_start TEXT NOT NULL DEFAULT (datetime('now')),
+        current_period_end TEXT,
+        canceled_at TEXT,
+        metadata TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS events (
+        id TEXT PRIMARY KEY,
+        subscriber_id TEXT NOT NULL REFERENCES subscribers(id) ON DELETE CASCADE,
+        type TEXT NOT NULL CHECK (type IN ('created', 'upgraded', 'downgraded', 'canceled', 'renewed', 'payment_failed')),
+        occurred_at TEXT NOT NULL DEFAULT (datetime('now')),
+        details TEXT NOT NULL DEFAULT '{}'
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_plans_active ON plans(active);
+      CREATE INDEX IF NOT EXISTS idx_subscribers_plan ON subscribers(plan_id);
+      CREATE INDEX IF NOT EXISTS idx_subscribers_email ON subscribers(customer_email);
+      CREATE INDEX IF NOT EXISTS idx_subscribers_status ON subscribers(status);
+      CREATE INDEX IF NOT EXISTS idx_subscribers_period_end ON subscribers(current_period_end);
+      CREATE INDEX IF NOT EXISTS idx_events_subscriber ON events(subscriber_id);
+      CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
+      CREATE INDEX IF NOT EXISTS idx_events_occurred ON events(occurred_at);
+    `,
+  },
+];