s3db.js 13.6.0 → 14.0.2

package/src/plugins/scheduler.plugin.js

@@ -80,7 +80,13 @@ import { SchedulerError } from "./scheduler.errors.js";
  *         if (backupPlugin) {
  *           return await backupPlugin.backup('incremental');
  *         }
- *         throw new Error('BackupPlugin not available');
+ *         throw new PluginError('BackupPlugin not available', {
+ *           pluginName: 'SchedulerPlugin',
+ *           operation: 'backupJob',
+ *           statusCode: 500,
+ *           retriable: false,
+ *           suggestion: 'Ensure BackupPlugin is installed before scheduling backup jobs.'
+ *         });
  *       },
  *       retries: 2
  *     },
@@ -94,7 +100,13 @@ import { SchedulerError } from "./scheduler.errors.js";
  *         if (backupPlugin) {
  *           return await backupPlugin.backup('full');
  *         }
- *         throw new Error('BackupPlugin not available');
+ *         throw new PluginError('BackupPlugin not available', {
+ *           pluginName: 'SchedulerPlugin',
+ *           operation: 'backupJob',
+ *           statusCode: 500,
+ *           retriable: false,
+ *           suggestion: 'Ensure BackupPlugin is installed before scheduling backup jobs.'
+ *         });
  *       }
  *     },
  *     
@@ -414,8 +426,8 @@ export class SchedulerPlugin extends Plugin {
 
     // Acquire distributed lock with TTL to prevent concurrent execution across instances
     const storage = this.getStorage();
-    const lockKey = `job-${jobName}`;
-    const lock = await storage.acquireLock(lockKey, {
+    const lockName = `job-${jobName}`;
+    const lock = await storage.acquireLock(lockName, {
       ttl: Math.ceil(job.timeout / 1000) + 60, // Job timeout + 60 seconds buffer
       timeout: 0, // Don't wait if locked
       workerId: process.pid ? String(process.pid) : 'unknown'
@@ -571,7 +583,9 @@ export class SchedulerPlugin extends Plugin {
       }
     } finally {
       // Always release the distributed lock
-      await tryFn(() => storage.releaseLock(lockKey));
+      if (lock) {
+        await tryFn(() => storage.releaseLock(lock));
+      }
     }
   }
 
@@ -921,4 +935,4 @@ export class SchedulerPlugin extends Plugin {
     this.activeJobs.clear();
     this.removeAllListeners();
   }
-}
+}

package/src/plugins/state-machine.plugin.js

@@ -1,5 +1,6 @@
 import { Plugin } from "./plugin.class.js";
 import tryFn from "../concerns/try-fn.js";
+import { resolveResourceNames } from "./concerns/resource-names.js";
 import { StateMachineError } from "./state-machine.errors.js";
 import { ErrorClassifier } from "../concerns/error-classifier.js";
 
@@ -102,13 +103,27 @@ export class StateMachinePlugin extends Plugin {
   constructor(options = {}) {
     super();
 
+    const resourceNamesOption = options.resourceNames || {};
+
+    this._resourceDescriptors = {
+      transitionLog: {
+        defaultName: 'plg_state_transitions',
+        override: resourceNamesOption.transitionLog || options.transitionLogResource
+      },
+      states: {
+        defaultName: 'plg_entity_states',
+        override: resourceNamesOption.states || options.stateResource
+      }
+    };
+    this.resourceNames = this._resolveResourceNames();
+
     this.config = {
       stateMachines: options.stateMachines || {},
       actions: options.actions || {},
       guards: options.guards || {},
       persistTransitions: options.persistTransitions !== false,
-      transitionLogResource: options.transitionLogResource || 'plg_state_transitions',
-      stateResource: options.stateResource || 'plg_entity_states',
+      transitionLogResource: this.resourceNames.transitionLog,
+      stateResource: this.resourceNames.states,
       retryAttempts: options.retryAttempts || 3,
       retryDelay: options.retryDelay || 100,
       verbose: options.verbose || false,
@@ -138,6 +153,20 @@ export class StateMachinePlugin extends Plugin {
     this._validateConfiguration();
   }
 
+  _resolveResourceNames() {
+    return resolveResourceNames('state_machine', this._resourceDescriptors, {
+      namespace: this.namespace
+    });
+  }
+
+  onNamespaceChanged() {
+    this.resourceNames = this._resolveResourceNames();
+    if (this.config) {
+      this.config.transitionLogResource = this.resourceNames.transitionLog;
+      this.config.stateResource = this.resourceNames.states;
+    }
+  }
+
   /**
    * Wait for all pending event handlers to complete
    * Useful when working with async events (asyncEvents: true)
@@ -290,7 +319,7 @@ export class StateMachinePlugin extends Plugin {
     }
 
     // Acquire distributed lock to prevent concurrent transitions
-    const lockName = await this._acquireTransitionLock(machineId, entityId);
+    const lock = await this._acquireTransitionLock(machineId, entityId);
 
     try {
       const currentState = await this.getState(machineId, entityId);
@@ -366,7 +395,7 @@ export class StateMachinePlugin extends Plugin {
       };
     } finally {
       // Always release lock, even if transition fails
-      await this._releaseTransitionLock(lockName);
+      await this._releaseTransitionLock(lock);
     }
   }
 
@@ -610,19 +639,21 @@ export class StateMachinePlugin extends Plugin {
       });
     }
 
-    return lockName;
+    return lock;
   }
 
   /**
    * Release distributed lock for transition
    * @private
    */
-  async _releaseTransitionLock(lockName) {
+  async _releaseTransitionLock(lock) {
+    if (!lock) return;
+
     const storage = this.getStorage();
-    const [ok, err] = await tryFn(() => storage.releaseLock(lockName));
+    const [ok, err] = await tryFn(() => storage.releaseLock(lock));
 
     if (!ok && this.config.verbose) {
-      console.warn(`[StateMachinePlugin] Failed to release lock '${lockName}':`, err.message);
+      console.warn(`[StateMachinePlugin] Failed to release lock '${lock?.name}':`, err.message);
     }
   }
 
@@ -1500,4 +1531,4 @@ export class StateMachinePlugin extends Plugin {
     this.machines.clear();
     this.removeAllListeners();
   }
-}
+}