@anteros/core 0.0.41 → 0.0.42

package/database/replication.ts

@@ -4,6 +4,7 @@ import { getTenant } from "./tenant";
 import { useRest } from "./rest";
 import { logger } from "../utils/logger";
 import * as func from "../utils/func";
+import * as os from "node:os";
 import type { Collection } from "../types/collection";
 import type { Tenant } from "../types/tenant";
 import type { HookContext } from "../types/hook";
@@ -11,6 +12,7 @@ import type {
     ReplicationConfig,
     ReplicationDestination,
     ReplicationInitialSync,
+    ReplicationMetaName,
     ReplicationResetOptions,
     ReplicationResetResult,
     ReplicationRunResult,
@@ -20,6 +22,10 @@ import type {
     ReplicationState,
     ReplicationStats,
 } from "../types/replication";
+import { AUDIT_TTL_INDEX, resolveAuditRetention } from "./audit";
+import { WORKFLOW_RUNS_TTL_INDEX, resolveWorkflowsRetention } from "../lib/workflow";
+import { agentMemoryCollections } from "../lib/agents";
+import { syncTtlRetention } from "./ttl";
 
 const META_COLLECTION = "_replication_";
 const DEFAULT_KEY = "updatedAt";
@@ -29,6 +35,76 @@ const BULK_CHUNK = 1000;
 /** Distributed-lock TTL used to guard a run across cluster workers. */
 const LOCK_TTL = 5 * 60_000;
 
+/**
+ * Framework collections replication covers **by default**, with the date key each
+ * one is read with (the engine's cursor). `'vars'` is handled apart, per namespace,
+ * and `'memory'` covers the agent memory collections — whose names the tenant
+ * chooses, so they come from the agent registry instead (see below).
+ */
+const META_COLLECTIONS: Record<Exclude<ReplicationMetaName, 'vars' | 'memory'>, { slug: string; key: string }> = {
+    audit: { slug: "_audit_", key: "ts" },
+    workflows: { slug: "_workflows_", key: "updatedAt" },
+    locks: { slug: "_locks_", key: "expiresAt" },
+    replication: { slug: "_replication_", key: "updatedAt" },
+};
+
+/**
+ * Everything replicated for a tenant: the collections that opted in, plus the
+ * framework's meta collections — which are replicated **by default** and left out
+ * with `replication.exclude: ['audit', 'locks', …]`.
+ */
+function replicatedCollectionsFor(tenantId: string, config: ReplicationConfig): Collection[] {
+    const excluded = new Set<string>(config.exclude ?? []);
+
+    const collections: Collection[] = [
+        ...(cfg.collections ?? []).filter((c) => c._tenant_ === tenantId && c.replication?.enabled),
+        ...(cfg.fileCollections ?? [])
+            .filter((c) => c._tenant_ === tenantId && c.replication?.enabled)
+            .map((c) => ({ slug: c.slug, _tenant_: tenantId, replication: c.replication }) as any),
+    ];
+
+    for (const [name, meta] of Object.entries(META_COLLECTIONS)) {
+        if (excluded.has(name)) continue;
+        // Each meta collection knows its own date key (`_audit_` is indexed on `ts`),
+        // so a tenant-level `key` never breaks it
+        collections.push({
+            slug: meta.slug,
+            _tenant_: tenantId,
+            replication: { enabled: true, key: meta.key },
+        } as any);
+    }
+
+    if (!excluded.has('vars')) {
+        // Every namespace, minus the ones explicitly opting out — a per-document
+        // filter: `replication.exclude: ['vars']` is the blunt way out.
+        const optedOut = (cfg.vars ?? [])
+            .filter((v) => v._tenant_ === tenantId && v.replication?.enabled === false)
+            .map((v) => v.namespace);
+        collections.push({
+            slug: "_vars_",
+            _tenant_: tenantId,
+            replication: { enabled: true },
+            _baseFilter_: { ns: { $nin: optedOut } },
+        } as any);
+    }
+
+    // Agent memory collections — the tenant names them, the agent loader publishes
+    // them (`cfg.agentMemories`). `exclude: ['memory']` covers all of them.
+    if (!excluded.has('memory')) {
+        for (const slug of agentMemoryCollections(tenantId)) {
+            // A memory collection may also be declared as a collection: one entry only
+            if (collections.some((collection) => collection.slug === slug)) continue;
+            collections.push({
+                slug,
+                _tenant_: tenantId,
+                replication: { enabled: true, key: "updatedAt" },
+            } as any);
+        }
+    }
+
+    return collections;
+}
+
 type Runtime = {
     tenantId: string;
     destination: ReplicationDestination;
@@ -221,6 +297,11 @@ async function saveState(
                 status,
                 error,
                 stats: { ...stats },
+                // Which process owns this run — `reusePort`/forked deployments can
+                // see at a glance which worker is replicating (the lock holds the
+                // same information)
+                pid: process.pid,
+                hostname: os.hostname(),
                 updatedAt: now,
             },
             $setOnInsert: { createdAt: now },
@@ -311,7 +392,15 @@ async function flushDeletes(
 
     const ops = markers.map((m: any) => ({
         deleteOne: {
-            filter: { _id: toId(m.docId), [key]: { $lte: m.deletedAt } },
+            filter: {
+                _id: toId(m.docId),
+                // The key is a Date on most collections, but a number on `_locks_`:
+                // accept either, so a numeric key never silently skips the delete
+                $or: [
+                    { [key]: { $lte: m.deletedAt } },
+                    { [key]: { $lte: m.deletedAt?.getTime?.() ?? m.deletedAt } },
+                ],
+            },
         },
     }));
     const res = await withRetry(() => runtime.db.collection(collection.slug).bulkWrite(ops as any, { ordered: false }));
@@ -388,6 +477,23 @@ async function replicateCollection(
     await ensureIndex(tenant.database.db!, collection.slug, key, "source");
     await ensureIndex(runtime.db, collection.slug, key, `destination:${runtime.destination.id}`);
 
+    // Meta collections have no hooks, so their deletions never reach the
+    // destination (an audit TTL expiry is invisible to a date cursor): mirror the
+    // source's retention on the destination, otherwise the copy grows forever.
+    if (collection.slug === '_audit_' || collection.slug === '_workflows_') {
+        const isAudit = collection.slug === '_audit_';
+        const retention = isAudit ? resolveAuditRetention(tenant) : resolveWorkflowsRetention(tenant);
+        if (retention !== undefined) {
+            await syncTtlRetention(runtime.db, {
+                collection: collection.slug,
+                index: isAudit ? AUDIT_TTL_INDEX : WORKFLOW_RUNS_TTL_INDEX,
+                field: isAudit ? 'ts' : 'completedAt',
+                retention,
+                label: `${collection.slug} (destination)`,
+            });
+        }
+    }
+
     // Resolve the initial cursor on the first run — `initialSync` lets a
     // pre-loaded destination skip the full backfill (`full` = default).
     if (!state) {
@@ -452,29 +558,7 @@ async function replicateTenant(
     const mainDb = tenant?.database?.db;
     if (!tenant || !config || !mainDb) return [];
 
-    const collections = (cfg.collections ?? []).filter((c) => c._tenant_ === tenantId && c.replication?.enabled);
-
-    // File collections opt in the same way (`define.FileCollection({ replication })`).
-    collections.push(
-        ...(cfg.fileCollections ?? [])
-            .filter((c) => c._tenant_ === tenantId && c.replication?.enabled)
-            .map((c) => ({ slug: c.slug, _tenant_: tenantId, replication: c.replication }) as any),
-    );
-
-    // `define.Vars({ replication: { enabled: true } })` → replicate the opted-in
-    // namespaces of `_vars_`. A per-document filter keeps the namespaces that
-    // did NOT opt in (e.g. secrets) out of the destination.
-    const varsNamespaces = (cfg.vars ?? [])
-        .filter((v) => v._tenant_ === tenantId && v.replication?.enabled)
-        .map((v) => v.namespace);
-    if (varsNamespaces.length) {
-        collections.push({
-            slug: "_vars_",
-            _tenant_: tenantId,
-            replication: { enabled: true },
-            _baseFilter_: { ns: { $in: varsNamespaces } },
-        } as any);
-    }
+    const collections = replicatedCollectionsFor(tenantId, config);
     const results: ReplicationRunResult[] = [];
     const meta = mainDb.collection(META_COLLECTION);
     const rest = new useRest({ tenant_id: tenantId });
@@ -606,14 +690,8 @@ async function seedReplication(
     if (!tenant || !config || !mainDb) return { tenant: tenantId, seeded: 0 };
 
     const meta: any = mainDb.collection(META_COLLECTION);
-    const collections = (cfg.collections ?? []).filter(
-        (c) => c._tenant_ === tenantId && c.replication?.enabled && (!opts?.collection || c.slug === opts.collection),
-    );
-    collections.push(
-        ...(cfg.fileCollections ?? [])
-            .filter((c) => c._tenant_ === tenantId && c.replication?.enabled && (!opts?.collection || c.slug === opts.collection))
-            .map((c) => ({ slug: c.slug, _tenant_: tenantId, replication: c.replication }) as any),
-    );
+    const collections = replicatedCollectionsFor(tenantId, config)
+        .filter((c) => !opts?.collection || c.slug === opts.collection);
     const destinations = (config.destinations ?? []).filter(
         (d) => d.enabled !== false && d.id && d.uri && (!opts?.destination || d.id === opts.destination),
     );

package/database/ttl.ts

@@ -0,0 +1,68 @@
+import type { Db } from "mongodb";
+import { parseDuration } from "../utils/func";
+
+export type RetentionResult = 'applied' | 'dropped' | 'unchanged' | 'skipped'
+
+/**
+ * Declarative TTL retention for a collection:
+ *
+ * - a duration string (`'90d'`, `'24h'`) → ensure the TTL index with that expiry
+ * - `false`                             → explicitly disabled: drop the TTL index
+ * - omitted                             → untouched
+ *
+ * MongoDB cannot change `expireAfterSeconds` in place through `createIndex`:
+ * `collMod` does it instantly, dropping/recreating is the fallback. Never fatal —
+ * a failure is logged and `'skipped'` is returned.
+ */
+async function syncTtlRetention(
+    db: Db,
+    opts: { collection: string; index: string; field: string; retention?: string | false; label?: string },
+): Promise<RetentionResult> {
+    const { collection, index, field, retention } = opts;
+    const label = opts.label ?? collection;
+
+    if (retention === undefined) return 'skipped';
+
+    const col: any = db.collection(collection);
+
+    try {
+        const existing = (await col.listIndexes().toArray())
+            .find((entry: any) => entry.name === index);
+
+        if (retention === false) {
+            if (!existing) return 'unchanged';
+            await col.dropIndex(index);
+            console.log(`🧹 ${label} retention disabled — ${index} dropped`);
+            return 'dropped';
+        }
+
+        const parsed = parseDuration(retention);
+        if (parsed === null) {
+            console.error(`Invalid ${label} retention '${retention}' — expected a duration like '90d' or '24h'`);
+            return 'skipped';
+        }
+        const expireAfterSeconds = Math.round(parsed / 1000);
+
+        if (!existing) {
+            await col.createIndex({ [field]: 1 }, { name: index, expireAfterSeconds, background: true });
+            console.log(`🧹 ${label} retention enabled — entries expire after ${retention}`);
+            return 'applied';
+        }
+
+        if (existing.expireAfterSeconds === expireAfterSeconds) return 'unchanged';
+
+        try {
+            await db.command({ collMod: collection, index: { name: index, expireAfterSeconds } });
+        } catch {
+            await col.dropIndex(index);
+            await col.createIndex({ [field]: 1 }, { name: index, expireAfterSeconds, background: true });
+        }
+        console.log(`🧹 ${label} retention updated — entries expire after ${retention}`);
+        return 'applied';
+    } catch (err: any) {
+        console.error(`${label} retention failed (${retention})`, err?.message);
+        return 'skipped';
+    }
+}
+
+export { syncTtlRetention }