@hasna/microservices 0.0.5 → 0.0.6

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

@@ -0,0 +1,93 @@
+/**
+ * Database connection for microservice-company
+ */
+
+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-company", "data.db");
+  }
+
+  // Check for .microservices in current or parent directories
+  let dir = resolve(process.cwd());
+  while (true) {
+    const candidate = join(dir, ".microservices", "microservice-company", "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-company", "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-company/src/db/migrations.ts

@@ -0,0 +1,214 @@
+export interface MigrationEntry {
+  id: number;
+  name: string;
+  sql: string;
+}
+
+export const MIGRATIONS: MigrationEntry[] = [
+  {
+    id: 1,
+    name: "core_organization",
+    sql: `
+      CREATE TABLE IF NOT EXISTS organizations (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        legal_name TEXT,
+        tax_id TEXT,
+        address TEXT NOT NULL DEFAULT '{}',
+        phone TEXT,
+        email TEXT,
+        website TEXT,
+        industry TEXT,
+        currency TEXT NOT NULL DEFAULT 'USD',
+        fiscal_year_start TEXT NOT NULL DEFAULT '01-01',
+        timezone TEXT NOT NULL DEFAULT 'UTC',
+        branding TEXT NOT NULL DEFAULT '{}',
+        settings 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 teams (
+        id TEXT PRIMARY KEY,
+        org_id TEXT NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+        name TEXT NOT NULL,
+        parent_id TEXT REFERENCES teams(id) ON DELETE SET NULL,
+        department TEXT,
+        cost_center TEXT,
+        metadata TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS members (
+        id TEXT PRIMARY KEY,
+        org_id TEXT NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+        team_id TEXT REFERENCES teams(id) ON DELETE SET NULL,
+        name TEXT NOT NULL,
+        email TEXT,
+        role TEXT NOT NULL DEFAULT 'member' CHECK (role IN ('owner', 'admin', 'manager', 'member', 'viewer')),
+        title TEXT,
+        permissions TEXT NOT NULL DEFAULT '{}',
+        status TEXT NOT NULL DEFAULT 'active',
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_teams_org ON teams(org_id);
+      CREATE INDEX IF NOT EXISTS idx_teams_parent ON teams(parent_id);
+      CREATE INDEX IF NOT EXISTS idx_members_org ON members(org_id);
+      CREATE INDEX IF NOT EXISTS idx_members_team ON members(team_id);
+      CREATE INDEX IF NOT EXISTS idx_members_email ON members(email);
+      CREATE INDEX IF NOT EXISTS idx_members_role ON members(role);
+    `,
+  },
+  {
+    id: 2,
+    name: "unified_entities",
+    sql: `
+      CREATE TABLE IF NOT EXISTS customers (
+        id TEXT PRIMARY KEY,
+        org_id TEXT NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+        name TEXT NOT NULL,
+        email TEXT,
+        phone TEXT,
+        company TEXT,
+        address TEXT NOT NULL DEFAULT '{}',
+        source TEXT,
+        source_ids TEXT NOT NULL DEFAULT '{}',
+        tags TEXT NOT NULL DEFAULT '[]',
+        lifetime_value REAL NOT NULL DEFAULT 0,
+        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 vendors (
+        id TEXT PRIMARY KEY,
+        org_id TEXT NOT NULL REFERENCES organizations(id) ON DELETE CASCADE,
+        name TEXT NOT NULL,
+        email TEXT,
+        phone TEXT,
+        company TEXT,
+        category TEXT CHECK (category IN ('supplier', 'contractor', 'partner', 'agency')),
+        payment_terms TEXT,
+        address TEXT NOT NULL DEFAULT '{}',
+        metadata TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_customers_org ON customers(org_id);
+      CREATE INDEX IF NOT EXISTS idx_customers_email ON customers(email);
+      CREATE INDEX IF NOT EXISTS idx_customers_name ON customers(name);
+      CREATE INDEX IF NOT EXISTS idx_vendors_org ON vendors(org_id);
+      CREATE INDEX IF NOT EXISTS idx_vendors_category ON vendors(category);
+      CREATE INDEX IF NOT EXISTS idx_vendors_name ON vendors(name);
+    `,
+  },
+  {
+    id: 3,
+    name: "workflow_engine",
+    sql: `
+      CREATE TABLE IF NOT EXISTS workflows (
+        id TEXT PRIMARY KEY,
+        org_id TEXT,
+        name TEXT NOT NULL,
+        trigger_event TEXT NOT NULL,
+        steps TEXT NOT NULL DEFAULT '[]',
+        enabled INTEGER NOT NULL DEFAULT 1,
+        last_run_at TEXT,
+        run_count INTEGER NOT NULL DEFAULT 0,
+        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 workflow_runs (
+        id TEXT PRIMARY KEY,
+        workflow_id TEXT NOT NULL REFERENCES workflows(id) ON DELETE CASCADE,
+        trigger_data TEXT,
+        status TEXT NOT NULL DEFAULT 'running',
+        steps_completed INTEGER NOT NULL DEFAULT 0,
+        steps_total INTEGER,
+        results TEXT NOT NULL DEFAULT '[]',
+        started_at TEXT NOT NULL DEFAULT (datetime('now')),
+        completed_at TEXT,
+        error TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_workflows_trigger ON workflows(trigger_event);
+      CREATE INDEX IF NOT EXISTS idx_workflows_org ON workflows(org_id);
+      CREATE INDEX IF NOT EXISTS idx_workflows_enabled ON workflows(enabled);
+      CREATE INDEX IF NOT EXISTS idx_workflow_runs_workflow ON workflow_runs(workflow_id);
+      CREATE INDEX IF NOT EXISTS idx_workflow_runs_status ON workflow_runs(status);
+    `,
+  },
+  {
+    id: 4,
+    name: "financial_periods",
+    sql: `
+      CREATE TABLE IF NOT EXISTS financial_periods (
+        id TEXT PRIMARY KEY,
+        org_id TEXT REFERENCES organizations(id) ON DELETE CASCADE,
+        name TEXT NOT NULL,
+        type TEXT NOT NULL CHECK (type IN ('month', 'quarter', 'year')),
+        start_date TEXT NOT NULL,
+        end_date TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'open' CHECK (status IN ('open', 'closing', 'closed')),
+        revenue REAL NOT NULL DEFAULT 0,
+        expenses REAL NOT NULL DEFAULT 0,
+        net_income REAL NOT NULL DEFAULT 0,
+        breakdown TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        closed_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS budgets (
+        id TEXT PRIMARY KEY,
+        org_id TEXT REFERENCES organizations(id) ON DELETE CASCADE,
+        department TEXT NOT NULL,
+        monthly_amount REAL NOT NULL,
+        currency TEXT NOT NULL DEFAULT 'USD',
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_financial_periods_org ON financial_periods(org_id);
+      CREATE INDEX IF NOT EXISTS idx_financial_periods_type ON financial_periods(type);
+      CREATE INDEX IF NOT EXISTS idx_financial_periods_status ON financial_periods(status);
+      CREATE INDEX IF NOT EXISTS idx_budgets_org ON budgets(org_id);
+      CREATE INDEX IF NOT EXISTS idx_budgets_department ON budgets(department);
+    `,
+  },
+  {
+    id: 5,
+    name: "audit_and_settings",
+    sql: `
+      CREATE TABLE IF NOT EXISTS audit_log (
+        id TEXT PRIMARY KEY,
+        org_id TEXT,
+        actor TEXT NOT NULL,
+        action TEXT NOT NULL CHECK(action IN ('create','update','delete','execute','login','approve')),
+        service TEXT,
+        entity_type TEXT,
+        entity_id TEXT,
+        details TEXT DEFAULT '{}',
+        timestamp TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_audit_actor ON audit_log(actor);
+      CREATE INDEX IF NOT EXISTS idx_audit_service ON audit_log(service);
+      CREATE INDEX IF NOT EXISTS idx_audit_timestamp ON audit_log(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_audit_entity ON audit_log(entity_type, entity_id);
+
+      CREATE TABLE IF NOT EXISTS company_settings (
+        id TEXT PRIMARY KEY,
+        org_id TEXT,
+        key TEXT NOT NULL,
+        value TEXT NOT NULL,
+        category TEXT,
+        UNIQUE(org_id, key)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_settings_category ON company_settings(category);
+    `,
+  },
+];

package/microservices/microservice-company/src/db/workflow-migrations.ts

@@ -0,0 +1,44 @@
+export interface MigrationEntry {
+  id: number;
+  name: string;
+  sql: string;
+}
+
+export const WORKFLOW_MIGRATION: MigrationEntry = {
+  id: 3,
+  name: "workflow_engine",
+  sql: `
+    CREATE TABLE IF NOT EXISTS workflows (
+      id TEXT PRIMARY KEY,
+      org_id TEXT,
+      name TEXT NOT NULL,
+      trigger_event TEXT NOT NULL,
+      steps TEXT NOT NULL DEFAULT '[]',
+      enabled INTEGER NOT NULL DEFAULT 1,
+      last_run_at TEXT,
+      run_count INTEGER NOT NULL DEFAULT 0,
+      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 workflow_runs (
+      id TEXT PRIMARY KEY,
+      workflow_id TEXT NOT NULL REFERENCES workflows(id) ON DELETE CASCADE,
+      trigger_data TEXT,
+      status TEXT NOT NULL DEFAULT 'running',
+      steps_completed INTEGER NOT NULL DEFAULT 0,
+      steps_total INTEGER,
+      results TEXT NOT NULL DEFAULT '[]',
+      started_at TEXT NOT NULL DEFAULT (datetime('now')),
+      completed_at TEXT,
+      error TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_workflows_trigger ON workflows(trigger_event);
+    CREATE INDEX IF NOT EXISTS idx_workflows_org ON workflows(org_id);
+    CREATE INDEX IF NOT EXISTS idx_workflows_enabled ON workflows(enabled);
+    CREATE INDEX IF NOT EXISTS idx_workflow_runs_workflow ON workflow_runs(workflow_id);
+    CREATE INDEX IF NOT EXISTS idx_workflow_runs_status ON workflow_runs(status);
+  `,
+};

package/microservices/microservice-company/src/index.ts

@@ -0,0 +1,60 @@
+/**
+ * microservice-company — AI agent control plane for autonomous company operations
+ */
+
+export {
+  createOrg,
+  getOrg,
+  updateOrg,
+  type Organization,
+  type CreateOrgInput,
+  type UpdateOrgInput,
+  createTeam,
+  getTeam,
+  listTeams,
+  updateTeam,
+  deleteTeam,
+  getTeamTree,
+  getTeamMembers,
+  type Team,
+  type TeamTreeNode,
+  type CreateTeamInput,
+  type UpdateTeamInput,
+  type ListTeamsOptions,
+  addMember,
+  getMember,
+  listMembers,
+  updateMember,
+  removeMember,
+  getMembersByRole,
+  getMembersByTeam,
+  type Member,
+  type AddMemberInput,
+  type UpdateMemberInput,
+  type ListMembersOptions,
+  createCustomer,
+  getCustomer,
+  listCustomers,
+  updateCustomer,
+  deleteCustomer,
+  searchCustomers,
+  mergeCustomers,
+  getCustomerByEmail,
+  type Customer,
+  type CreateCustomerInput,
+  type UpdateCustomerInput,
+  type ListCustomersOptions,
+  createVendor,
+  getVendor,
+  listVendors,
+  updateVendor,
+  deleteVendor,
+  searchVendors,
+  getVendorsByCategory,
+  type Vendor,
+  type CreateVendorInput,
+  type UpdateVendorInput,
+  type ListVendorsOptions,
+} from "./db/company.js";
+
+export { getDatabase, closeDatabase } from "./db/database.js";

package/microservices/microservice-company/src/lib/audit.ts

@@ -0,0 +1,168 @@
+/**
+ * Audit log operations — track actions across the company microservice
+ */
+
+import { getDatabase } from "../db/database.js";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+export type AuditAction = "create" | "update" | "delete" | "execute" | "login" | "approve";
+
+export interface AuditEntry {
+  id: string;
+  org_id: string | null;
+  actor: string;
+  action: AuditAction;
+  service: string | null;
+  entity_type: string | null;
+  entity_id: string | null;
+  details: Record<string, unknown>;
+  timestamp: string;
+}
+
+interface AuditRow {
+  id: string;
+  org_id: string | null;
+  actor: string;
+  action: string;
+  service: string | null;
+  entity_type: string | null;
+  entity_id: string | null;
+  details: string;
+  timestamp: string;
+}
+
+function rowToAudit(row: AuditRow): AuditEntry {
+  return {
+    ...row,
+    action: row.action as AuditAction,
+    details: JSON.parse(row.details || "{}"),
+  };
+}
+
+// ─── Operations ──────────────────────────────────────────────────────────────
+
+export interface LogActionInput {
+  org_id?: string;
+  actor: string;
+  action: AuditAction;
+  service?: string;
+  entity_type?: string;
+  entity_id?: string;
+  details?: Record<string, unknown>;
+}
+
+export function logAction(input: LogActionInput): AuditEntry {
+  const db = getDatabase();
+  const id = crypto.randomUUID();
+
+  db.prepare(
+    `INSERT INTO audit_log (id, org_id, actor, action, service, entity_type, entity_id, details)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    input.org_id || null,
+    input.actor,
+    input.action,
+    input.service || null,
+    input.entity_type || null,
+    input.entity_id || null,
+    JSON.stringify(input.details || {})
+  );
+
+  const row = db.prepare("SELECT * FROM audit_log WHERE id = ?").get(id) as AuditRow;
+  return rowToAudit(row);
+}
+
+export interface SearchAuditFilters {
+  org_id?: string;
+  actor?: string;
+  service?: string;
+  action?: AuditAction;
+  entity_type?: string;
+  entity_id?: string;
+  from?: string;
+  to?: string;
+  limit?: number;
+}
+
+export function searchAudit(filters: SearchAuditFilters = {}): AuditEntry[] {
+  const db = getDatabase();
+  const conditions: string[] = [];
+  const params: unknown[] = [];
+
+  if (filters.org_id) { conditions.push("org_id = ?"); params.push(filters.org_id); }
+  if (filters.actor) { conditions.push("actor = ?"); params.push(filters.actor); }
+  if (filters.service) { conditions.push("service = ?"); params.push(filters.service); }
+  if (filters.action) { conditions.push("action = ?"); params.push(filters.action); }
+  if (filters.entity_type) { conditions.push("entity_type = ?"); params.push(filters.entity_type); }
+  if (filters.entity_id) { conditions.push("entity_id = ?"); params.push(filters.entity_id); }
+  if (filters.from) { conditions.push("timestamp >= ?"); params.push(filters.from); }
+  if (filters.to) { conditions.push("timestamp <= ?"); params.push(filters.to); }
+
+  let sql = "SELECT * FROM audit_log";
+  if (conditions.length > 0) sql += " WHERE " + conditions.join(" AND ");
+  sql += " ORDER BY timestamp DESC";
+
+  if (filters.limit) { sql += " LIMIT ?"; params.push(filters.limit); }
+
+  const rows = db.prepare(sql).all(...params) as AuditRow[];
+  return rows.map(rowToAudit);
+}
+
+export function getAuditTimeline(entityType: string, entityId: string): AuditEntry[] {
+  const db = getDatabase();
+  const rows = db.prepare(
+    "SELECT * FROM audit_log WHERE entity_type = ? AND entity_id = ? ORDER BY timestamp ASC"
+  ).all(entityType, entityId) as AuditRow[];
+  return rows.map(rowToAudit);
+}
+
+export interface AuditStats {
+  total: number;
+  by_actor: Record<string, number>;
+  by_service: Record<string, number>;
+  by_action: Record<string, number>;
+}
+
+export function getAuditStats(orgId?: string, from?: string, to?: string): AuditStats {
+  const db = getDatabase();
+  const conditions: string[] = [];
+  const params: unknown[] = [];
+
+  if (orgId) { conditions.push("org_id = ?"); params.push(orgId); }
+  if (from) { conditions.push("timestamp >= ?"); params.push(from); }
+  if (to) { conditions.push("timestamp <= ?"); params.push(to); }
+
+  const where = conditions.length > 0 ? " WHERE " + conditions.join(" AND ") : "";
+
+  const totalRow = db.prepare(`SELECT COUNT(*) as count FROM audit_log${where}`).get(...params) as { count: number };
+
+  const actorRows = db.prepare(
+    `SELECT actor, COUNT(*) as count FROM audit_log${where} GROUP BY actor`
+  ).all(...params) as { actor: string; count: number }[];
+
+  const serviceRows = db.prepare(
+    `SELECT service, COUNT(*) as count FROM audit_log${where} GROUP BY service`
+  ).all(...params) as { service: string; count: number }[];
+
+  const actionRows = db.prepare(
+    `SELECT action, COUNT(*) as count FROM audit_log${where} GROUP BY action`
+  ).all(...params) as { action: string; count: number }[];
+
+  const by_actor: Record<string, number> = {};
+  for (const r of actorRows) by_actor[r.actor] = r.count;
+
+  const by_service: Record<string, number> = {};
+  for (const r of serviceRows) by_service[r.service || "unknown"] = r.count;
+
+  const by_action: Record<string, number> = {};
+  for (const r of actionRows) by_action[r.action] = r.count;
+
+  return {
+    total: totalRow.count,
+    by_actor,
+    by_service,
+    by_action,
+  };
+}