@hasna/microservices 0.0.4 → 0.0.6

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

@@ -7,7 +7,7 @@ import { getDatabase } from "./database.js";
 // --- Contract types ---
 
 export type ContractType = "nda" | "service" | "employment" | "license" | "other";
-export type ContractStatus = "draft" | "pending_signature" | "active" | "expired" | "terminated";
+export type ContractStatus = "draft" | "pending_review" | "pending_signature" | "active" | "expired" | "terminated";
 
 export interface Contract {
   id: string;
@@ -245,6 +245,9 @@ export function updateContract(
 
   if (sets.length === 0) return existing;
 
+  // Save version history before updating
+  saveContractVersion(existing);
+
   sets.push("updated_at = datetime('now')");
   params.push(id);
 
@@ -494,3 +497,429 @@ export function markReminderSent(id: string): boolean {
     .run(id);
   return result.changes > 0;
 }
+
+// --- Obligation operations ---
+
+export type ObligationStatus = "pending" | "completed" | "overdue";
+
+export interface Obligation {
+  id: string;
+  clause_id: string;
+  description: string;
+  due_date: string | null;
+  status: ObligationStatus;
+  assigned_to: string | null;
+  created_at: string;
+}
+
+export interface CreateObligationInput {
+  clause_id: string;
+  description: string;
+  due_date?: string;
+  assigned_to?: string;
+}
+
+export function createObligation(input: CreateObligationInput): Obligation {
+  const db = getDatabase();
+  const id = crypto.randomUUID();
+
+  db.prepare(
+    `INSERT INTO obligations (id, clause_id, description, due_date, assigned_to)
+     VALUES (?, ?, ?, ?, ?)`
+  ).run(id, input.clause_id, input.description, input.due_date || null, input.assigned_to || null);
+
+  return getObligation(id)!;
+}
+
+export function getObligation(id: string): Obligation | null {
+  const db = getDatabase();
+  const row = db.prepare("SELECT * FROM obligations WHERE id = ?").get(id) as Obligation | null;
+  return row || null;
+}
+
+export function listObligations(clauseId: string): Obligation[] {
+  const db = getDatabase();
+  return db
+    .prepare("SELECT * FROM obligations WHERE clause_id = ? ORDER BY created_at ASC")
+    .all(clauseId) as Obligation[];
+}
+
+export function completeObligation(id: string): Obligation | null {
+  const db = getDatabase();
+  const result = db
+    .prepare("UPDATE obligations SET status = 'completed' WHERE id = ?")
+    .run(id);
+  if (result.changes === 0) return null;
+  return getObligation(id);
+}
+
+export function listOverdueObligations(): Obligation[] {
+  const db = getDatabase();
+  // Mark obligations past due_date as overdue, then return them
+  db.prepare(
+    `UPDATE obligations SET status = 'overdue'
+     WHERE status = 'pending' AND due_date IS NOT NULL AND date(due_date) < date('now')`
+  ).run();
+
+  return db
+    .prepare(
+      `SELECT * FROM obligations
+       WHERE status = 'overdue'
+       ORDER BY due_date ASC`
+    )
+    .all() as Obligation[];
+}
+
+// --- Approval workflow ---
+
+const APPROVAL_FLOW: Record<string, string> = {
+  draft: "pending_review",
+  pending_review: "pending_signature",
+  pending_signature: "active",
+};
+
+/**
+ * Submit a draft contract for review: draft -> pending_review
+ */
+export function submitForReview(id: string): Contract | null {
+  const contract = getContract(id);
+  if (!contract) return null;
+  if (contract.status !== "draft") {
+    throw new Error(`Cannot submit for review: contract status is '${contract.status}', expected 'draft'`);
+  }
+  return updateContract(id, { status: "pending_review" });
+}
+
+/**
+ * Approve a contract: pending_review -> pending_signature -> active
+ * Advances the contract one step in the approval flow.
+ */
+export function approveContract(id: string): Contract | null {
+  const contract = getContract(id);
+  if (!contract) return null;
+  const nextStatus = APPROVAL_FLOW[contract.status];
+  if (!nextStatus) {
+    throw new Error(
+      `Cannot approve: contract status is '${contract.status}'. Approval flow: draft -> pending_review -> pending_signature -> active`
+    );
+  }
+  return updateContract(id, { status: nextStatus as ContractStatus });
+}
+
+// --- Version history ---
+
+export interface ContractVersion {
+  id: string;
+  contract_id: string;
+  title: string;
+  status: string;
+  value: number | null;
+  metadata_snapshot: Record<string, unknown>;
+  changed_at: string;
+}
+
+interface ContractVersionRow {
+  id: string;
+  contract_id: string;
+  title: string;
+  status: string;
+  value: number | null;
+  metadata_snapshot: string;
+  changed_at: string;
+}
+
+function rowToVersion(row: ContractVersionRow): ContractVersion {
+  return {
+    ...row,
+    metadata_snapshot: JSON.parse(row.metadata_snapshot || "{}"),
+  };
+}
+
+function saveContractVersion(contract: Contract): void {
+  const db = getDatabase();
+  const id = crypto.randomUUID();
+  db.prepare(
+    `INSERT INTO contract_versions (id, contract_id, title, status, value, metadata_snapshot)
+     VALUES (?, ?, ?, ?, ?, ?)`
+  ).run(
+    id,
+    contract.id,
+    contract.title,
+    contract.status,
+    contract.value,
+    JSON.stringify(contract.metadata)
+  );
+}
+
+export function getContractHistory(contractId: string): ContractVersion[] {
+  const db = getDatabase();
+  const rows = db
+    .prepare("SELECT * FROM contract_versions WHERE contract_id = ? ORDER BY changed_at ASC")
+    .all(contractId) as ContractVersionRow[];
+  return rows.map(rowToVersion);
+}
+
+// --- Signature logging ---
+
+export type SignatureMethod = "digital" | "wet" | "docusign";
+
+export interface Signature {
+  id: string;
+  contract_id: string;
+  signer_name: string;
+  signer_email: string | null;
+  signed_at: string;
+  method: SignatureMethod;
+}
+
+export interface RecordSignatureInput {
+  contract_id: string;
+  signer_name: string;
+  signer_email?: string;
+  method?: SignatureMethod;
+}
+
+export function recordSignature(input: RecordSignatureInput): Signature {
+  const db = getDatabase();
+  const id = crypto.randomUUID();
+
+  db.prepare(
+    `INSERT INTO signatures (id, contract_id, signer_name, signer_email, method)
+     VALUES (?, ?, ?, ?, ?)`
+  ).run(id, input.contract_id, input.signer_name, input.signer_email || null, input.method || "digital");
+
+  return getSignature(id)!;
+}
+
+export function getSignature(id: string): Signature | null {
+  const db = getDatabase();
+  const row = db.prepare("SELECT * FROM signatures WHERE id = ?").get(id) as Signature | null;
+  return row || null;
+}
+
+export function listSignatures(contractId: string): Signature[] {
+  const db = getDatabase();
+  return db
+    .prepare("SELECT * FROM signatures WHERE contract_id = ? ORDER BY signed_at ASC")
+    .all(contractId) as Signature[];
+}
+
+// --- Clause templates (library) ---
+
+export interface ClauseTemplate {
+  id: string;
+  name: string;
+  text: string;
+  type: "standard" | "custom" | "negotiated";
+  created_at: string;
+}
+
+export interface SaveClauseTemplateInput {
+  name: string;
+  text: string;
+  type?: "standard" | "custom" | "negotiated";
+}
+
+export function saveClauseTemplate(input: SaveClauseTemplateInput): ClauseTemplate {
+  const db = getDatabase();
+  const id = crypto.randomUUID();
+
+  db.prepare(
+    `INSERT INTO clause_templates (id, name, text, type)
+     VALUES (?, ?, ?, ?)`
+  ).run(id, input.name, input.text, input.type || "standard");
+
+  return getClauseTemplate(id)!;
+}
+
+export function getClauseTemplate(id: string): ClauseTemplate | null {
+  const db = getDatabase();
+  const row = db.prepare("SELECT * FROM clause_templates WHERE id = ?").get(id) as ClauseTemplate | null;
+  return row || null;
+}
+
+export function getClauseTemplateByName(name: string): ClauseTemplate | null {
+  const db = getDatabase();
+  const row = db.prepare("SELECT * FROM clause_templates WHERE name = ?").get(name) as ClauseTemplate | null;
+  return row || null;
+}
+
+export function listClauseTemplates(): ClauseTemplate[] {
+  const db = getDatabase();
+  return db
+    .prepare("SELECT * FROM clause_templates ORDER BY name ASC")
+    .all() as ClauseTemplate[];
+}
+
+export function addClauseFromTemplate(contractId: string, templateName: string): Clause {
+  const template = getClauseTemplateByName(templateName);
+  if (!template) {
+    throw new Error(`Clause template '${templateName}' not found`);
+  }
+  return createClause({
+    contract_id: contractId,
+    name: template.name,
+    text: template.text,
+    type: template.type,
+  });
+}
+
+// --- Multi-stage reminders ---
+
+export function setMultiReminders(
+  contractId: string,
+  daysBefore: number[]
+): Reminder[] {
+  const contract = getContract(contractId);
+  if (!contract) {
+    throw new Error(`Contract '${contractId}' not found`);
+  }
+  if (!contract.end_date) {
+    throw new Error(`Contract '${contractId}' has no end_date set`);
+  }
+
+  const endDate = new Date(contract.end_date);
+  const reminders: Reminder[] = [];
+
+  for (const days of daysBefore) {
+    const remindDate = new Date(endDate);
+    remindDate.setDate(remindDate.getDate() - days);
+    const remindAt = remindDate.toISOString().split("T")[0] + "T09:00:00";
+
+    const reminder = createReminder({
+      contract_id: contractId,
+      remind_at: remindAt,
+      message: `Contract "${contract.title}" expires in ${days} day(s)`,
+    });
+    reminders.push(reminder);
+  }
+
+  return reminders;
+}
+
+// --- Contract comparison ---
+
+export interface ContractComparison {
+  contract1: { id: string; title: string };
+  contract2: { id: string; title: string };
+  field_differences: { field: string; contract1_value: unknown; contract2_value: unknown }[];
+  clause_only_in_1: Clause[];
+  clause_only_in_2: Clause[];
+  clause_differences: { name: string; contract1_text: string; contract2_text: string }[];
+}
+
+export function compareContracts(id1: string, id2: string): ContractComparison {
+  const c1 = getContract(id1);
+  const c2 = getContract(id2);
+  if (!c1) throw new Error(`Contract '${id1}' not found`);
+  if (!c2) throw new Error(`Contract '${id2}' not found`);
+
+  // Compare fields
+  const fieldsToCompare: (keyof Contract)[] = [
+    "title", "type", "status", "counterparty", "counterparty_email",
+    "start_date", "end_date", "auto_renew", "renewal_period",
+    "value", "currency",
+  ];
+  const field_differences: { field: string; contract1_value: unknown; contract2_value: unknown }[] = [];
+  for (const field of fieldsToCompare) {
+    const v1 = c1[field];
+    const v2 = c2[field];
+    if (JSON.stringify(v1) !== JSON.stringify(v2)) {
+      field_differences.push({ field, contract1_value: v1, contract2_value: v2 });
+    }
+  }
+
+  // Compare clauses by name
+  const clauses1 = listClauses(id1);
+  const clauses2 = listClauses(id2);
+  const names1 = new Set(clauses1.map((c) => c.name));
+  const names2 = new Set(clauses2.map((c) => c.name));
+
+  const clause_only_in_1 = clauses1.filter((c) => !names2.has(c.name));
+  const clause_only_in_2 = clauses2.filter((c) => !names1.has(c.name));
+
+  const clause_differences: { name: string; contract1_text: string; contract2_text: string }[] = [];
+  for (const cl1 of clauses1) {
+    const cl2 = clauses2.find((c) => c.name === cl1.name);
+    if (cl2 && cl1.text !== cl2.text) {
+      clause_differences.push({ name: cl1.name, contract1_text: cl1.text, contract2_text: cl2.text });
+    }
+  }
+
+  return {
+    contract1: { id: c1.id, title: c1.title },
+    contract2: { id: c2.id, title: c2.title },
+    field_differences,
+    clause_only_in_1,
+    clause_only_in_2,
+    clause_differences,
+  };
+}
+
+// --- Markdown export ---
+
+export function exportContract(id: string, format: "md" | "json" = "md"): string {
+  const contract = getContract(id);
+  if (!contract) throw new Error(`Contract '${id}' not found`);
+
+  if (format === "json") {
+    const clauses = listClauses(id);
+    const sigs = listSignatures(id);
+    const reminders = listReminders(id);
+    return JSON.stringify({ contract, clauses, signatures: sigs, reminders }, null, 2);
+  }
+
+  // Markdown export
+  const lines: string[] = [];
+  lines.push(`# ${contract.title}`);
+  lines.push("");
+  lines.push(`| Field | Value |`);
+  lines.push(`|-------|-------|`);
+  lines.push(`| Type | ${contract.type} |`);
+  lines.push(`| Status | ${contract.status} |`);
+  if (contract.counterparty) lines.push(`| Counterparty | ${contract.counterparty} |`);
+  if (contract.counterparty_email) lines.push(`| Email | ${contract.counterparty_email} |`);
+  if (contract.start_date) lines.push(`| Start Date | ${contract.start_date} |`);
+  if (contract.end_date) lines.push(`| End Date | ${contract.end_date} |`);
+  if (contract.value !== null) lines.push(`| Value | ${contract.value} ${contract.currency} |`);
+  if (contract.auto_renew) lines.push(`| Auto-Renew | ${contract.renewal_period || "1 year"} |`);
+  lines.push(`| Created | ${contract.created_at} |`);
+  lines.push(`| Updated | ${contract.updated_at} |`);
+
+  const clauses = listClauses(id);
+  if (clauses.length > 0) {
+    lines.push("");
+    lines.push("## Clauses");
+    lines.push("");
+    for (const clause of clauses) {
+      lines.push(`### ${clause.name} (${clause.type})`);
+      lines.push("");
+      lines.push(clause.text);
+      lines.push("");
+    }
+  }
+
+  const sigs = listSignatures(id);
+  if (sigs.length > 0) {
+    lines.push("## Signatures");
+    lines.push("");
+    for (const sig of sigs) {
+      const email = sig.signer_email ? ` (${sig.signer_email})` : "";
+      lines.push(`- **${sig.signer_name}**${email} — ${sig.method} — ${sig.signed_at}`);
+    }
+    lines.push("");
+  }
+
+  const reminders = listReminders(id);
+  if (reminders.length > 0) {
+    lines.push("## Reminders");
+    lines.push("");
+    for (const r of reminders) {
+      const sent = r.sent ? " (sent)" : "";
+      lines.push(`- ${r.remind_at} — ${r.message}${sent}`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}

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

@@ -55,4 +55,87 @@ export const MIGRATIONS: MigrationEntry[] = [
       CREATE INDEX IF NOT EXISTS idx_reminders_remind_at ON reminders(remind_at);
     `,
   },
+  {
+    id: 2,
+    name: "qol_features",
+    sql: `
+      -- Obligation tracking
+      CREATE TABLE IF NOT EXISTS obligations (
+        id TEXT PRIMARY KEY,
+        clause_id TEXT NOT NULL REFERENCES clauses(id) ON DELETE CASCADE,
+        description TEXT NOT NULL,
+        due_date TEXT,
+        status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'completed', 'overdue')),
+        assigned_to TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_obligations_clause ON obligations(clause_id);
+      CREATE INDEX IF NOT EXISTS idx_obligations_status ON obligations(status);
+      CREATE INDEX IF NOT EXISTS idx_obligations_due_date ON obligations(due_date);
+
+      -- Rebuild contracts table to add pending_review status
+      CREATE TABLE contracts_new (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        type TEXT NOT NULL DEFAULT 'other' CHECK (type IN ('nda', 'service', 'employment', 'license', 'other')),
+        status TEXT NOT NULL DEFAULT 'draft' CHECK (status IN ('draft', 'pending_review', 'pending_signature', 'active', 'expired', 'terminated')),
+        counterparty TEXT,
+        counterparty_email TEXT,
+        start_date TEXT,
+        end_date TEXT,
+        auto_renew INTEGER NOT NULL DEFAULT 0,
+        renewal_period TEXT,
+        value REAL,
+        currency TEXT NOT NULL DEFAULT 'USD',
+        file_path TEXT,
+        metadata TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      INSERT INTO contracts_new SELECT * FROM contracts;
+      DROP TABLE contracts;
+      ALTER TABLE contracts_new RENAME TO contracts;
+
+      CREATE INDEX IF NOT EXISTS idx_contracts_status ON contracts(status);
+      CREATE INDEX IF NOT EXISTS idx_contracts_type ON contracts(type);
+      CREATE INDEX IF NOT EXISTS idx_contracts_counterparty ON contracts(counterparty);
+      CREATE INDEX IF NOT EXISTS idx_contracts_end_date ON contracts(end_date);
+
+      -- Contract versions (history)
+      CREATE TABLE IF NOT EXISTS contract_versions (
+        id TEXT PRIMARY KEY,
+        contract_id TEXT NOT NULL REFERENCES contracts(id) ON DELETE CASCADE,
+        title TEXT NOT NULL,
+        status TEXT NOT NULL,
+        value REAL,
+        metadata_snapshot TEXT NOT NULL DEFAULT '{}',
+        changed_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_contract_versions_contract ON contract_versions(contract_id);
+
+      -- Signatures
+      CREATE TABLE IF NOT EXISTS signatures (
+        id TEXT PRIMARY KEY,
+        contract_id TEXT NOT NULL REFERENCES contracts(id) ON DELETE CASCADE,
+        signer_name TEXT NOT NULL,
+        signer_email TEXT,
+        signed_at TEXT NOT NULL DEFAULT (datetime('now')),
+        method TEXT NOT NULL DEFAULT 'digital' CHECK (method IN ('digital', 'wet', 'docusign'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_signatures_contract ON signatures(contract_id);
+
+      -- Clause templates (library)
+      CREATE TABLE IF NOT EXISTS clause_templates (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        text TEXT NOT NULL,
+        type TEXT NOT NULL DEFAULT 'standard' CHECK (type IN ('standard', 'custom', 'negotiated')),
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+    `,
+  },
 ];