s3db.js 10.0.12 → 10.0.14

package/src/plugins/eventual-consistency.plugin.js

@@ -317,10 +317,20 @@ export class EventualConsistencyPlugin extends Plugin {
   }
 
   async onStart() {
-    // Emit events for all field handlers
+    // Start timers and emit events for all field handlers
     for (const [resourceName, fieldHandlers] of this.fieldHandlers) {
       for (const [fieldName, handler] of fieldHandlers) {
         if (!handler.deferredSetup) {
+          // Start auto-consolidation timer if enabled
+          if (this.config.autoConsolidate && this.config.mode === 'async') {
+            this.startConsolidationTimerForHandler(handler, resourceName, fieldName);
+          }
+
+          // Start garbage collection timer
+          if (this.config.transactionRetention && this.config.transactionRetention > 0) {
+            this.startGarbageCollectionTimerForHandler(handler, resourceName, fieldName);
+          }
+
           this.emit('eventual-consistency.started', {
             resource: resourceName,
             field: fieldName,
@@ -467,20 +477,57 @@ export class EventualConsistencyPlugin extends Plugin {
     // Add method to set value (replaces current value)
     // Signature: set(id, field, value)
     resource.set = async (id, field, value) => {
-      const { plugin: fieldPlugin } =
+      const { plugin: handler } =
         plugin._resolveFieldAndPlugin(resource, field, value);
 
-      // Create set transaction
-      await fieldPlugin.createTransaction(fieldPlugin, {
+      // Create transaction inline
+      const now = new Date();
+      const cohortInfo = plugin.getCohortInfo(now);
+
+      const transaction = {
+        id: idGenerator(),
         originalId: id,
-        operation: 'set',
+        field: handler.field,
         value: value,
-        source: 'set'
-      });
+        operation: 'set',
+        timestamp: now.toISOString(),
+        cohortDate: cohortInfo.date,
+        cohortHour: cohortInfo.hour,
+        cohortMonth: cohortInfo.month,
+        source: 'set',
+        applied: false
+      };
+
+      await handler.transactionResource.insert(transaction);
+
+      // In sync mode, immediately consolidate
+      if (plugin.config.mode === 'sync') {
+        // Temporarily set config for legacy methods
+        const oldResource = plugin.config.resource;
+        const oldField = plugin.config.field;
+        const oldTransactionResource = plugin.transactionResource;
+        const oldTargetResource = plugin.targetResource;
+        const oldLockResource = plugin.lockResource;
+        const oldAnalyticsResource = plugin.analyticsResource;
 
-      // In sync mode, immediately consolidate and update (atomic with locking)
-      if (fieldPlugin.config.mode === 'sync') {
-        return await fieldPlugin._syncModeConsolidate(fieldPlugin, id, field);
+        plugin.config.resource = handler.resource;
+        plugin.config.field = handler.field;
+        plugin.transactionResource = handler.transactionResource;
+        plugin.targetResource = handler.targetResource;
+        plugin.lockResource = handler.lockResource;
+        plugin.analyticsResource = handler.analyticsResource;
+
+        const result = await plugin._syncModeConsolidate(id, field);
+
+        // Restore
+        plugin.config.resource = oldResource;
+        plugin.config.field = oldField;
+        plugin.transactionResource = oldTransactionResource;
+        plugin.targetResource = oldTargetResource;
+        plugin.lockResource = oldLockResource;
+        plugin.analyticsResource = oldAnalyticsResource;
+
+        return result;
       }
 
       return value;
@@ -489,48 +536,120 @@ export class EventualConsistencyPlugin extends Plugin {
     // Add method to increment value
     // Signature: add(id, field, amount)
     resource.add = async (id, field, amount) => {
-      const { plugin: fieldPlugin } =
+      const { plugin: handler } =
         plugin._resolveFieldAndPlugin(resource, field, amount);
 
-      // Create add transaction
-      await fieldPlugin.createTransaction(fieldPlugin, {
+      // Create transaction inline
+      const now = new Date();
+      const cohortInfo = plugin.getCohortInfo(now);
+
+      const transaction = {
+        id: idGenerator(),
         originalId: id,
-        operation: 'add',
+        field: handler.field,
         value: amount,
-        source: 'add'
-      });
+        operation: 'add',
+        timestamp: now.toISOString(),
+        cohortDate: cohortInfo.date,
+        cohortHour: cohortInfo.hour,
+        cohortMonth: cohortInfo.month,
+        source: 'add',
+        applied: false
+      };
 
-      // In sync mode, immediately consolidate and update (atomic with locking)
-      if (fieldPlugin.config.mode === 'sync') {
-        return await fieldPlugin._syncModeConsolidate(fieldPlugin, id, field);
-      }
+      await handler.transactionResource.insert(transaction);
 
-      // In async mode, return expected value (for user feedback)
-      const currentValue = await fieldPlugin.getConsolidatedValue(fieldPlugin, id);
+      // In sync mode, immediately consolidate
+      if (plugin.config.mode === 'sync') {
+        const oldResource = plugin.config.resource;
+        const oldField = plugin.config.field;
+        const oldTransactionResource = plugin.transactionResource;
+        const oldTargetResource = plugin.targetResource;
+        const oldLockResource = plugin.lockResource;
+        const oldAnalyticsResource = plugin.analyticsResource;
+
+        plugin.config.resource = handler.resource;
+        plugin.config.field = handler.field;
+        plugin.transactionResource = handler.transactionResource;
+        plugin.targetResource = handler.targetResource;
+        plugin.lockResource = handler.lockResource;
+        plugin.analyticsResource = handler.analyticsResource;
+
+        const result = await plugin._syncModeConsolidate(id, field);
+
+        plugin.config.resource = oldResource;
+        plugin.config.field = oldField;
+        plugin.transactionResource = oldTransactionResource;
+        plugin.targetResource = oldTargetResource;
+        plugin.lockResource = oldLockResource;
+        plugin.analyticsResource = oldAnalyticsResource;
+
+        return result;
+      }
+
+      // Async mode - return current value (optimistic)
+      const [ok, err, record] = await tryFn(() => handler.targetResource.get(id));
+      const currentValue = (ok && record) ? (record[field] || 0) : 0;
       return currentValue + amount;
     };
 
     // Add method to decrement value
     // Signature: sub(id, field, amount)
     resource.sub = async (id, field, amount) => {
-      const { plugin: fieldPlugin } =
+      const { plugin: handler } =
         plugin._resolveFieldAndPlugin(resource, field, amount);
 
-      // Create sub transaction
-      await fieldPlugin.createTransaction(fieldPlugin, {
+      // Create transaction inline
+      const now = new Date();
+      const cohortInfo = plugin.getCohortInfo(now);
+
+      const transaction = {
+        id: idGenerator(),
         originalId: id,
-        operation: 'sub',
+        field: handler.field,
         value: amount,
-        source: 'sub'
-      });
+        operation: 'sub',
+        timestamp: now.toISOString(),
+        cohortDate: cohortInfo.date,
+        cohortHour: cohortInfo.hour,
+        cohortMonth: cohortInfo.month,
+        source: 'sub',
+        applied: false
+      };
 
-      // In sync mode, immediately consolidate and update (atomic with locking)
-      if (fieldPlugin.config.mode === 'sync') {
-        return await fieldPlugin._syncModeConsolidate(fieldPlugin, id, field);
-      }
+      await handler.transactionResource.insert(transaction);
 
-      // In async mode, return expected value (for user feedback)
-      const currentValue = await fieldPlugin.getConsolidatedValue(fieldPlugin, id);
+      // In sync mode, immediately consolidate
+      if (plugin.config.mode === 'sync') {
+        const oldResource = plugin.config.resource;
+        const oldField = plugin.config.field;
+        const oldTransactionResource = plugin.transactionResource;
+        const oldTargetResource = plugin.targetResource;
+        const oldLockResource = plugin.lockResource;
+        const oldAnalyticsResource = plugin.analyticsResource;
+
+        plugin.config.resource = handler.resource;
+        plugin.config.field = handler.field;
+        plugin.transactionResource = handler.transactionResource;
+        plugin.targetResource = handler.targetResource;
+        plugin.lockResource = handler.lockResource;
+        plugin.analyticsResource = handler.analyticsResource;
+
+        const result = await plugin._syncModeConsolidate(id, field);
+
+        plugin.config.resource = oldResource;
+        plugin.config.field = oldField;
+        plugin.transactionResource = oldTransactionResource;
+        plugin.targetResource = oldTargetResource;
+        plugin.lockResource = oldLockResource;
+        plugin.analyticsResource = oldAnalyticsResource;
+
+        return result;
+      }
+
+      // Async mode - return current value (optimistic)
+      const [ok, err, record] = await tryFn(() => handler.targetResource.get(id));
+      const currentValue = (ok && record) ? (record[field] || 0) : 0;
       return currentValue - amount;
     };
 
@@ -541,9 +660,9 @@ export class EventualConsistencyPlugin extends Plugin {
         throw new Error(`Field parameter is required: consolidate(id, field)`);
       }
 
-      const fieldPlugin = resource._eventualConsistencyPlugins[field];
+      const handler = resource._eventualConsistencyPlugins[field];
 
-      if (!fieldPlugin) {
+      if (!handler) {
         const availableFields = Object.keys(resource._eventualConsistencyPlugins).join(', ');
         throw new Error(
           `No eventual consistency plugin found for field "${field}". ` +
@@ -551,15 +670,39 @@ export class EventualConsistencyPlugin extends Plugin {
         );
       }
 
-      return await fieldPlugin.consolidateRecord(fieldPlugin, id);
+      // Temporarily set config for legacy methods
+      const oldResource = plugin.config.resource;
+      const oldField = plugin.config.field;
+      const oldTransactionResource = plugin.transactionResource;
+      const oldTargetResource = plugin.targetResource;
+      const oldLockResource = plugin.lockResource;
+      const oldAnalyticsResource = plugin.analyticsResource;
+
+      plugin.config.resource = handler.resource;
+      plugin.config.field = handler.field;
+      plugin.transactionResource = handler.transactionResource;
+      plugin.targetResource = handler.targetResource;
+      plugin.lockResource = handler.lockResource;
+      plugin.analyticsResource = handler.analyticsResource;
+
+      const result = await plugin.consolidateRecord(id);
+
+      plugin.config.resource = oldResource;
+      plugin.config.field = oldField;
+      plugin.transactionResource = oldTransactionResource;
+      plugin.targetResource = oldTargetResource;
+      plugin.lockResource = oldLockResource;
+      plugin.analyticsResource = oldAnalyticsResource;
+
+      return result;
     };
 
     // Add method to get consolidated value without applying
     // Signature: getConsolidatedValue(id, field, options)
     resource.getConsolidatedValue = async (id, field, options = {}) => {
-      const fieldPlugin = resource._eventualConsistencyPlugins[field];
+      const handler = resource._eventualConsistencyPlugins[field];
 
-      if (!fieldPlugin) {
+      if (!handler) {
         const availableFields = Object.keys(resource._eventualConsistencyPlugins).join(', ');
         throw new Error(
           `No eventual consistency plugin found for field "${field}". ` +
@@ -567,7 +710,25 @@ export class EventualConsistencyPlugin extends Plugin {
         );
       }
 
-      return await fieldPlugin.getConsolidatedValue(fieldPlugin, id, options);
+      // Temporarily set config for legacy methods
+      const oldResource = plugin.config.resource;
+      const oldField = plugin.config.field;
+      const oldTransactionResource = plugin.transactionResource;
+      const oldTargetResource = plugin.targetResource;
+
+      plugin.config.resource = handler.resource;
+      plugin.config.field = handler.field;
+      plugin.transactionResource = handler.transactionResource;
+      plugin.targetResource = handler.targetResource;
+
+      const result = await plugin.getConsolidatedValue(id, options);
+
+      plugin.config.resource = oldResource;
+      plugin.config.field = oldField;
+      plugin.transactionResource = oldTransactionResource;
+      plugin.targetResource = oldTargetResource;
+
+      return result;
     };
   }
 
@@ -746,6 +907,52 @@ export class EventualConsistencyPlugin extends Plugin {
     }, intervalMs);
   }
 
+  startConsolidationTimerForHandler(handler, resourceName, fieldName) {
+    const intervalMs = this.config.consolidationInterval * 1000; // Convert seconds to ms
+
+    if (this.config.verbose) {
+      const nextRun = new Date(Date.now() + intervalMs);
+      console.log(
+        `[EventualConsistency] ${resourceName}.${fieldName} - ` +
+        `Consolidation timer started. Next run at ${nextRun.toISOString()} ` +
+        `(every ${this.config.consolidationInterval}s)`
+      );
+    }
+
+    handler.consolidationTimer = setInterval(async () => {
+      await this.runConsolidationForHandler(handler, resourceName, fieldName);
+    }, intervalMs);
+  }
+
+  async runConsolidationForHandler(handler, resourceName, fieldName) {
+    // Temporarily swap config to use this handler
+    const oldResource = this.config.resource;
+    const oldField = this.config.field;
+    const oldTransactionResource = this.transactionResource;
+    const oldTargetResource = this.targetResource;
+    const oldLockResource = this.lockResource;
+    const oldAnalyticsResource = this.analyticsResource;
+
+    this.config.resource = resourceName;
+    this.config.field = fieldName;
+    this.transactionResource = handler.transactionResource;
+    this.targetResource = handler.targetResource;
+    this.lockResource = handler.lockResource;
+    this.analyticsResource = handler.analyticsResource;
+
+    try {
+      await this.runConsolidation();
+    } finally {
+      // Restore
+      this.config.resource = oldResource;
+      this.config.field = oldField;
+      this.transactionResource = oldTransactionResource;
+      this.targetResource = oldTargetResource;
+      this.lockResource = oldLockResource;
+      this.analyticsResource = oldAnalyticsResource;
+    }
+  }
+
   async runConsolidation() {
     const startTime = Date.now();
 
@@ -885,14 +1092,7 @@ export class EventualConsistencyPlugin extends Plugin {
     }
 
     try {
-      // Get the current record value first
-      const [recordOk, recordErr, record] = await tryFn(() =>
-        this.targetResource.get(originalId)
-      );
-
-      const currentValue = (recordOk && record) ? (record[this.config.field] || 0) : 0;
-
-      // Get all transactions for this record
+      // Get all unapplied transactions for this record
       const [ok, err, transactions] = await tryFn(() =>
         this.transactionResource.query({
           originalId,
@@ -901,6 +1101,12 @@ export class EventualConsistencyPlugin extends Plugin {
       );
 
       if (!ok || !transactions || transactions.length === 0) {
+        // No pending transactions - try to get current value from record
+        const [recordOk, recordErr, record] = await tryFn(() =>
+          this.targetResource.get(originalId)
+        );
+        const currentValue = (recordOk && record) ? (record[this.config.field] || 0) : 0;
+
         if (this.config.verbose) {
           console.log(
             `[EventualConsistency] ${this.config.resource}.${this.config.field} - ` +
@@ -910,20 +1116,169 @@ export class EventualConsistencyPlugin extends Plugin {
         return currentValue;
       }
 
+      // Get the LAST APPLIED VALUE from transactions (not from record - avoids S3 eventual consistency issues)
+      // This is the source of truth for the current value
+      const [appliedOk, appliedErr, appliedTransactions] = await tryFn(() =>
+        this.transactionResource.query({
+          originalId,
+          applied: true
+        })
+      );
+
+      let currentValue = 0;
+
+      if (appliedOk && appliedTransactions && appliedTransactions.length > 0) {
+        // Check if record exists - if deleted, ignore old applied transactions
+        const [recordExistsOk, recordExistsErr, recordExists] = await tryFn(() =>
+          this.targetResource.get(originalId)
+        );
+
+        if (!recordExistsOk || !recordExists) {
+          // Record was deleted - ignore applied transactions and start fresh
+          // This prevents old values from being carried over after deletion
+          if (this.config.verbose) {
+            console.log(
+              `[EventualConsistency] ${this.config.resource}.${this.config.field} - ` +
+              `Record ${originalId} doesn't exist, deleting ${appliedTransactions.length} old applied transactions`
+            );
+          }
+
+          // Delete old applied transactions to prevent them from being used when record is recreated
+          const { results, errors } = await PromisePool
+            .for(appliedTransactions)
+            .withConcurrency(10)
+            .process(async (txn) => {
+              const [deleted] = await tryFn(() => this.transactionResource.delete(txn.id));
+              return deleted;
+            });
+
+          if (this.config.verbose && errors && errors.length > 0) {
+            console.warn(
+              `[EventualConsistency] ${this.config.resource}.${this.config.field} - ` +
+              `Failed to delete ${errors.length} old applied transactions`
+            );
+          }
+
+          currentValue = 0;
+        } else {
+          // Record exists - use applied transactions to calculate current value
+          // Sort by timestamp to get chronological order
+          appliedTransactions.sort((a, b) =>
+            new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+          );
+
+          // Check if there's a 'set' operation in applied transactions
+          const hasSetInApplied = appliedTransactions.some(t => t.operation === 'set');
+
+          if (!hasSetInApplied) {
+            // No 'set' operation in applied transactions means we're missing the base value
+            // This can only happen if:
+            // 1. Record had an initial value before first transaction
+            // 2. First consolidation didn't create an anchor transaction (legacy behavior)
+            // Solution: Get the current record value and create an anchor transaction now
+            const recordValue = recordExists[this.config.field] || 0;
+
+            // Calculate what the base value was by subtracting all applied deltas
+            let appliedDelta = 0;
+            for (const t of appliedTransactions) {
+              if (t.operation === 'add') appliedDelta += t.value;
+              else if (t.operation === 'sub') appliedDelta -= t.value;
+            }
+
+            const baseValue = recordValue - appliedDelta;
+
+            // Create and save anchor transaction with the base value
+            // Only create if baseValue is non-zero AND we don't already have an anchor transaction
+            const hasExistingAnchor = appliedTransactions.some(t => t.source === 'anchor');
+            if (baseValue !== 0 && !hasExistingAnchor) {
+              // Use the timestamp of the first applied transaction for cohort info
+              const firstTransactionDate = new Date(appliedTransactions[0].timestamp);
+              const cohortInfo = this.getCohortInfo(firstTransactionDate);
+              const anchorTransaction = {
+                id: idGenerator(),
+                originalId: originalId,
+                field: this.config.field,
+                value: baseValue,
+                operation: 'set',
+                timestamp: new Date(firstTransactionDate.getTime() - 1).toISOString(), // 1ms before first txn to ensure it's first
+                cohortDate: cohortInfo.date,
+                cohortHour: cohortInfo.hour,
+                cohortMonth: cohortInfo.month,
+                source: 'anchor',
+                applied: true
+              };
+
+              await this.transactionResource.insert(anchorTransaction);
+
+              // Prepend to applied transactions for this consolidation
+              appliedTransactions.unshift(anchorTransaction);
+            }
+          }
+
+          // Apply reducer to get the last consolidated value
+          currentValue = this.config.reducer(appliedTransactions);
+        }
+      } else {
+        // No applied transactions - this is the FIRST consolidation
+        // Try to get initial value from record
+        const [recordOk, recordErr, record] = await tryFn(() =>
+          this.targetResource.get(originalId)
+        );
+        currentValue = (recordOk && record) ? (record[this.config.field] || 0) : 0;
+
+        // If there's an initial value, create and save an anchor transaction
+        // This ensures all future consolidations have a reliable base value
+        if (currentValue !== 0) {
+          // Use timestamp of the first pending transaction (or current time if none)
+          let anchorTimestamp;
+          if (transactions && transactions.length > 0) {
+            const firstPendingDate = new Date(transactions[0].timestamp);
+            anchorTimestamp = new Date(firstPendingDate.getTime() - 1).toISOString();
+          } else {
+            anchorTimestamp = new Date().toISOString();
+          }
+
+          const cohortInfo = this.getCohortInfo(new Date(anchorTimestamp));
+          const anchorTransaction = {
+            id: idGenerator(),
+            originalId: originalId,
+            field: this.config.field,
+            value: currentValue,
+            operation: 'set',
+            timestamp: anchorTimestamp,
+            cohortDate: cohortInfo.date,
+            cohortHour: cohortInfo.hour,
+            cohortMonth: cohortInfo.month,
+            source: 'anchor',
+            applied: true
+          };
+
+          await this.transactionResource.insert(anchorTransaction);
+
+          if (this.config.verbose) {
+            console.log(
+              `[EventualConsistency] ${this.config.resource}.${this.config.field} - ` +
+              `Created anchor transaction for ${originalId} with base value ${currentValue}`
+            );
+          }
+        }
+      }
+
       if (this.config.verbose) {
         console.log(
           `[EventualConsistency] ${this.config.resource}.${this.config.field} - ` +
           `Consolidating ${originalId}: ${transactions.length} pending transactions ` +
-          `(current: ${currentValue})`
+          `(current: ${currentValue} from ${appliedOk && appliedTransactions?.length > 0 ? 'applied transactions' : 'record'})`
         );
       }
 
-      // Sort transactions by timestamp
+      // Sort pending transactions by timestamp
       transactions.sort((a, b) =>
         new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
       );
 
-      // If there's a current value and no 'set' operations, prepend a synthetic set transaction
+      // If there's a current value and no 'set' operations in pending transactions,
+      // prepend a synthetic set transaction to preserve the current value
       const hasSetOperation = transactions.some(t => t.operation === 'set');
       if (currentValue !== 0 && !hasSetOperation) {
         transactions.unshift(this._createSyntheticSetTransaction(currentValue));
@@ -1035,7 +1390,7 @@ export class EventualConsistencyPlugin extends Plugin {
         }
 
         // Invalidate cache for this record after consolidation
-        if (this.targetResource.cache && typeof this.targetResource.cache.delete === 'function') {
+        if (this.targetResource && this.targetResource.cache && typeof this.targetResource.cache.delete === 'function') {
           try {
             const cacheKey = await this.targetResource.cacheKeyFor({ id: originalId });
             await this.targetResource.cache.delete(cacheKey);
@@ -1244,6 +1599,40 @@ export class EventualConsistencyPlugin extends Plugin {
     }, gcIntervalMs);
   }
 
+  startGarbageCollectionTimerForHandler(handler, resourceName, fieldName) {
+    const gcIntervalMs = this.config.gcInterval * 1000; // Convert seconds to ms
+
+    handler.gcTimer = setInterval(async () => {
+      await this.runGarbageCollectionForHandler(handler, resourceName, fieldName);
+    }, gcIntervalMs);
+  }
+
+  async runGarbageCollectionForHandler(handler, resourceName, fieldName) {
+    // Temporarily swap config to use this handler
+    const oldResource = this.config.resource;
+    const oldField = this.config.field;
+    const oldTransactionResource = this.transactionResource;
+    const oldTargetResource = this.targetResource;
+    const oldLockResource = this.lockResource;
+
+    this.config.resource = resourceName;
+    this.config.field = fieldName;
+    this.transactionResource = handler.transactionResource;
+    this.targetResource = handler.targetResource;
+    this.lockResource = handler.lockResource;
+
+    try {
+      await this.runGarbageCollection();
+    } finally {
+      // Restore
+      this.config.resource = oldResource;
+      this.config.field = oldField;
+      this.transactionResource = oldTransactionResource;
+      this.targetResource = oldTargetResource;
+      this.lockResource = oldLockResource;
+    }
+  }
+
   /**
    * Delete old applied transactions based on retention policy
    * Uses distributed locking to prevent multiple containers from running GC simultaneously
@@ -1634,14 +2023,25 @@ export class EventualConsistencyPlugin extends Plugin {
    * @returns {Promise<Array>} Analytics data
    */
   async getAnalytics(resourceName, field, options = {}) {
-    if (!this.analyticsResource) {
+    // Get handler for this resource/field combination
+    const fieldHandlers = this.fieldHandlers.get(resourceName);
+    if (!fieldHandlers) {
+      throw new Error(`No eventual consistency configured for resource: ${resourceName}`);
+    }
+
+    const handler = fieldHandlers.get(field);
+    if (!handler) {
+      throw new Error(`No eventual consistency configured for field: ${resourceName}.${field}`);
+    }
+
+    if (!handler.analyticsResource) {
       throw new Error('Analytics not enabled for this plugin');
     }
 
     const { period = 'day', date, startDate, endDate, month, year, breakdown = false } = options;
 
     const [ok, err, allAnalytics] = await tryFn(() =>
-      this.analyticsResource.list()
+      handler.analyticsResource.list()
     );
 
     if (!ok || !allAnalytics) {
@@ -1921,7 +2321,18 @@ export class EventualConsistencyPlugin extends Plugin {
    * @returns {Promise<Array>} Top records
    */
   async getTopRecords(resourceName, field, options = {}) {
-    if (!this.transactionResource) {
+    // Get handler for this resource/field combination
+    const fieldHandlers = this.fieldHandlers.get(resourceName);
+    if (!fieldHandlers) {
+      throw new Error(`No eventual consistency configured for resource: ${resourceName}`);
+    }
+
+    const handler = fieldHandlers.get(field);
+    if (!handler) {
+      throw new Error(`No eventual consistency configured for field: ${resourceName}.${field}`);
+    }
+
+    if (!handler.transactionResource) {
       throw new Error('Transaction resource not initialized');
     }
 
@@ -1929,7 +2340,7 @@ export class EventualConsistencyPlugin extends Plugin {
 
     // Get all transactions for the period
     const [ok, err, transactions] = await tryFn(() =>
-      this.transactionResource.list()
+      handler.transactionResource.list()
     );
 
     if (!ok || !transactions) {