s3db.js 13.2.1 → 13.3.0

package/dist/s3db.cjs.js

@@ -5186,7 +5186,7 @@ class AuditPlugin extends Plugin {
   async onStop() {
   }
   setupResourceAuditing(resource) {
-    resource.on("insert", async (data) => {
+    resource.on("inserted", async (data) => {
       const partitionValues = this.config.includePartitions ? this.getPartitionValues(data, resource) : null;
       await this.logAudit({
         resourceName: resource.name,
@@ -5198,7 +5198,7 @@ class AuditPlugin extends Plugin {
         partitionValues: partitionValues ? JSON.stringify(partitionValues) : null
       });
     });
-    resource.on("update", async (data) => {
+    resource.on("updated", async (data) => {
       let oldData = data.$before;
       if (this.config.includeData && !oldData) {
         const [ok, err, fetched] = await tryFn(() => resource.get(data.id));
@@ -5215,7 +5215,7 @@ class AuditPlugin extends Plugin {
         partitionValues: partitionValues ? JSON.stringify(partitionValues) : null
       });
     });
-    resource.on("delete", async (data) => {
+    resource.on("deleted", async (data) => {
       let oldData = data;
       if (this.config.includeData && !oldData) {
         const [ok, err, fetched] = await tryFn(() => resource.get(data.id));
@@ -7320,13 +7320,13 @@ class Cache extends EventEmitter {
   async get(key) {
     this.validateKey(key);
     const data = await this._get(key);
-    this.emit("get", data);
+    this.emit("fetched", data);
     return data;
   }
   async del(key) {
     this.validateKey(key);
     const data = await this._del(key);
-    this.emit("delete", data);
+    this.emit("deleted", data);
     return data;
   }
   async delete(key) {
@@ -9141,8 +9141,7 @@ class CostsPlugin extends Plugin {
   }
   async onStart() {
     if (this.client) {
-      this.client.on("command.response", (name, response, input) => this.addRequest(name, this.map[name], response, input));
-      this.client.on("command.error", (name, response, input) => this.addRequest(name, this.map[name], response, input));
+      this.client.on("cl:response", (name, response, input) => this.addRequest(name, this.map[name], response, input));
     }
   }
   addRequest(name, method, response = {}, input = {}) {
@@ -17724,7 +17723,7 @@ class BaseReplicator extends EventEmitter {
    */
   async initialize(database) {
     this.database = database;
-    this.emit("initialized", { replicator: this.name });
+    this.emit("db:plugin:initialized", { replicator: this.name });
   }
   /**
    * Replicate data to the target
@@ -18295,7 +18294,7 @@ class BigqueryReplicator extends BaseReplicator {
     if (this.schemaSync.enabled) {
       await this.syncSchemas(database);
     }
-    this.emit("initialized", {
+    this.emit("db:plugin:initialized", {
       replicator: this.name,
       projectId: this.projectId,
       datasetId: this.datasetId,
@@ -18602,7 +18601,7 @@ class BigqueryReplicator extends BaseReplicator {
       if (errors.length > 0) {
         console.warn(`[BigqueryReplicator] Replication completed with errors for ${resourceName}:`, errors);
       }
-      this.emit("replicated", {
+      this.emit("plg:replicator:replicated", {
         replicator: this.name,
         resourceName,
         operation,
@@ -18623,7 +18622,7 @@ class BigqueryReplicator extends BaseReplicator {
     if (this.config.verbose) {
       console.warn(`[BigqueryReplicator] Replication failed for ${resourceName}: ${err.message}`);
     }
-    this.emit("replicator_error", {
+    this.emit("plg:replicator:error", {
       replicator: this.name,
       resourceName,
       operation,
@@ -19898,7 +19897,7 @@ ${createSQL}`);
       }
     }
     const success = errors.length === 0;
-    this.emit("replicated", {
+    this.emit("plg:replicator:replicated", {
       replicator: this.name,
       resourceName,
       operation,
@@ -20043,7 +20042,7 @@ class PostgresReplicator extends BaseReplicator {
     if (this.schemaSync.enabled) {
       await this.syncSchemas(database);
     }
-    this.emit("initialized", {
+    this.emit("db:plugin:initialized", {
       replicator: this.name,
       database: this.database || "postgres",
       resources: Object.keys(this.resources)
@@ -20249,7 +20248,7 @@ ${createSQL}`);
       if (errors.length > 0) {
         console.warn(`[PostgresReplicator] Replication completed with errors for ${resourceName}:`, errors);
       }
-      this.emit("replicated", {
+      this.emit("plg:replicator:replicated", {
         replicator: this.name,
         resourceName,
         operation,
@@ -20270,7 +20269,7 @@ ${createSQL}`);
     if (this.config.verbose) {
       console.warn(`[PostgresReplicator] Replication failed for ${resourceName}: ${err.message}`);
     }
-    this.emit("replicator_error", {
+    this.emit("plg:replicator:error", {
       replicator: this.name,
       resourceName,
       operation,
@@ -23939,7 +23938,7 @@ ${errorDetails}`,
       data = await this.applyVersionMapping(data, objectVersion, this.version);
     }
     data = await this.executeHooks("afterGet", data);
-    this._emitWithDeprecation("get", "fetched", data, data.id);
+    this._emitStandardized("fetched", data, data.id);
     const value = data;
     return value;
   }
@@ -24649,26 +24648,6 @@ ${errorDetails}`,
     await this.executeHooks("beforeDelete", objectData);
     const key = this.getResourceKey(id);
     const [ok2, err2, response] = await tryFn(() => this.client.deleteObject(key));
-    this._emitWithDeprecation("delete", "deleted", {
-      ...objectData,
-      $before: { ...objectData },
-      $after: null
-    }, id);
-    if (deleteError) {
-      throw mapAwsError(deleteError, {
-        bucket: this.client.config.bucket,
-        key,
-        resourceName: this.name,
-        operation: "delete",
-        id
-      });
-    }
-    if (!ok2) throw mapAwsError(err2, {
-      key,
-      resourceName: this.name,
-      operation: "delete",
-      id
-    });
     if (this.config.partitions && Object.keys(this.config.partitions).length > 0 && objectData) {
       if (this.config.strictPartitions) {
         await this.deletePartitionReferences(objectData);
@@ -24701,11 +24680,30 @@ ${errorDetails}`,
       for (const hook of nonPartitionHooks) {
         afterDeleteData = await hook(afterDeleteData);
       }
-      return response;
     } else {
       await this.executeHooks("afterDelete", objectData);
-      return response;
     }
+    this._emitStandardized("deleted", {
+      ...objectData,
+      $before: { ...objectData },
+      $after: null
+    }, id);
+    if (deleteError) {
+      throw mapAwsError(deleteError, {
+        bucket: this.client.config.bucket,
+        key,
+        resourceName: this.name,
+        operation: "delete",
+        id
+      });
+    }
+    if (!ok2) throw mapAwsError(err2, {
+      key,
+      resourceName: this.name,
+      operation: "delete",
+      id
+    });
+    return response;
   }
   /**
    * Insert or update a resource object (upsert operation)
@@ -24777,7 +24775,7 @@ ${errorDetails}`,
     }
     const count = await this.client.count({ prefix });
     await this.executeHooks("afterCount", { count, partition, partitionValues });
-    this._emitWithDeprecation("count", "counted", count);
+    this._emitStandardized("count", count);
     return count;
   }
   /**
@@ -24800,7 +24798,7 @@ ${errorDetails}`,
       const result = await this.insert(attributes);
       return result;
     });
-    this._emitWithDeprecation("insertMany", "inserted-many", objects.length);
+    this._emitStandardized("inserted-many", objects.length);
     return results;
   }
   /**
@@ -24835,7 +24833,7 @@ ${errorDetails}`,
       return response;
     });
     await this.executeHooks("afterDeleteMany", { ids, results });
-    this._emitWithDeprecation("deleteMany", "deleted-many", ids.length);
+    this._emitStandardized("deleted-many", ids.length);
     return results;
   }
   async deleteAll() {
@@ -24844,7 +24842,7 @@ ${errorDetails}`,
     }
     const prefix = `resource=${this.name}/data`;
     const deletedCount = await this.client.deleteAll({ prefix });
-    this._emitWithDeprecation("deleteAll", "deleted-all", {
+    this._emitStandardized("deleted-all", {
       version: this.version,
       prefix,
       deletedCount
@@ -24861,7 +24859,7 @@ ${errorDetails}`,
     }
     const prefix = `resource=${this.name}`;
     const deletedCount = await this.client.deleteAll({ prefix });
-    this._emitWithDeprecation("deleteAllData", "deleted-all-data", {
+    this._emitStandardized("deleted-all-data", {
       resource: this.name,
       prefix,
       deletedCount
@@ -24931,7 +24929,7 @@ ${errorDetails}`,
       const idPart = parts.find((part) => part.startsWith("id="));
       return idPart ? idPart.replace("id=", "") : null;
     }).filter(Boolean);
-    this._emitWithDeprecation("listIds", "listed-ids", ids.length);
+    this._emitStandardized("listed-ids", ids.length);
     return ids;
   }
   /**
@@ -24973,12 +24971,12 @@ ${errorDetails}`,
     const [ok, err, ids] = await tryFn(() => this.listIds({ limit, offset }));
     if (!ok) throw err;
     const results = await this.processListResults(ids, "main");
-    this._emitWithDeprecation("list", "listed", { count: results.length, errors: 0 });
+    this._emitStandardized("list", { count: results.length, errors: 0 });
     return results;
   }
   async listPartition({ partition, partitionValues, limit, offset = 0 }) {
     if (!this.config.partitions?.[partition]) {
-      this._emitWithDeprecation("list", "listed", { partition, partitionValues, count: 0, errors: 0 });
+      this._emitStandardized("list", { partition, partitionValues, count: 0, errors: 0 });
       return [];
     }
     const partitionDef = this.config.partitions[partition];
@@ -24988,7 +24986,7 @@ ${errorDetails}`,
     const ids = this.extractIdsFromKeys(keys).slice(offset);
     const filteredIds = limit ? ids.slice(0, limit) : ids;
     const results = await this.processPartitionResults(filteredIds, partition, partitionDef, keys);
-    this._emitWithDeprecation("list", "listed", { partition, partitionValues, count: results.length, errors: 0 });
+    this._emitStandardized("list", { partition, partitionValues, count: results.length, errors: 0 });
     return results;
   }
   /**
@@ -25033,7 +25031,7 @@ ${errorDetails}`,
       }
       return this.handleResourceError(err, id, context);
     });
-    this._emitWithDeprecation("list", "listed", { count: results.length, errors: 0 });
+    this._emitStandardized("list", { count: results.length, errors: 0 });
     return results;
   }
   /**
@@ -25096,10 +25094,10 @@ ${errorDetails}`,
    */
   handleListError(error, { partition, partitionValues }) {
     if (error.message.includes("Partition '") && error.message.includes("' not found")) {
-      this._emitWithDeprecation("list", "listed", { partition, partitionValues, count: 0, errors: 1 });
+      this._emitStandardized("list", { partition, partitionValues, count: 0, errors: 1 });
       return [];
     }
-    this._emitWithDeprecation("list", "listed", { partition, partitionValues, count: 0, errors: 1 });
+    this._emitStandardized("list", { partition, partitionValues, count: 0, errors: 1 });
     return [];
   }
   /**
@@ -25132,7 +25130,7 @@ ${errorDetails}`,
       throw err;
     });
     const finalResults = await this.executeHooks("afterGetMany", results);
-    this._emitWithDeprecation("getMany", "fetched-many", ids.length);
+    this._emitStandardized("fetched-many", ids.length);
     return finalResults;
   }
   /**
@@ -25218,7 +25216,7 @@ ${errorDetails}`,
           hasTotalItems: totalItems !== null
         }
       };
-      this._emitWithDeprecation("page", "paginated", result2);
+      this._emitStandardized("paginated", result2);
       return result2;
     });
     if (ok) return result;
@@ -25288,7 +25286,7 @@ ${errorDetails}`,
       contentType
     }));
     if (!ok2) throw err2;
-    this._emitWithDeprecation("setContent", "content-set", { id, contentType, contentLength: buffer.length }, id);
+    this._emitStandardized("content-set", { id, contentType, contentLength: buffer.length }, id);
     return updatedData;
   }
   /**
@@ -25317,7 +25315,7 @@ ${errorDetails}`,
     }
     const buffer = Buffer.from(await response.Body.transformToByteArray());
     const contentType = response.ContentType || null;
-    this._emitWithDeprecation("content", "content-fetched", { id, contentLength: buffer.length, contentType }, id);
+    this._emitStandardized("content-fetched", { id, contentLength: buffer.length, contentType }, id);
     return {
       buffer,
       contentType
@@ -25349,7 +25347,7 @@ ${errorDetails}`,
       metadata: existingMetadata
     }));
     if (!ok2) throw err2;
-    this._emitWithDeprecation("deleteContent", "content-deleted", id, id);
+    this._emitStandardized("content-deleted", id, id);
     return response;
   }
   /**
@@ -25661,7 +25659,7 @@ ${errorDetails}`,
     const data = await this.get(id);
     data._partition = partitionName;
     data._partitionValues = partitionValues;
-    this._emitWithDeprecation("getFromPartition", "partition-fetched", data, data.id);
+    this._emitStandardized("partition-fetched", data, data.id);
     return data;
   }
   /**
@@ -25910,6 +25908,120 @@ ${errorDetails}`,
     }
     return out;
   }
+  // ============================================================================
+  // STATE MACHINE METHODS
+  // ============================================================================
+  /**
+   * State machine accessor object
+   * Provides namespaced access to state machine operations
+   * @type {Object}
+   * @property {Function} send - Trigger state transition
+   * @property {Function} get - Get current state
+   * @property {Function} canTransition - Check if transition is valid
+   * @property {Function} getValidEvents - Get valid events for current state
+   * @property {Function} initialize - Initialize entity with initial state
+   * @property {Function} history - Get transition history
+   * @example
+   * await orders.state.send('order-123', 'CONFIRM');
+   * const state = await orders.state.get('order-123');
+   * const canShip = await orders.state.canTransition('order-123', 'SHIP');
+   */
+  get state() {
+    const resource = this;
+    const throwIfNoStateMachine = () => {
+      if (!resource._stateMachine) {
+        throw new Error(
+          `No state machine configured for resource '${resource.name}'. Ensure StateMachinePlugin is installed and configured for this resource.`
+        );
+      }
+    };
+    return {
+      /**
+       * Trigger a state transition
+       * @param {string} id - Entity ID
+       * @param {string} event - Event name
+       * @param {Object} [eventData] - Event data
+       * @returns {Promise<Object>} Transition result
+       * @example
+       * await orders.state.send('order-123', 'CONFIRM', { confirmedBy: 'user-456' });
+       */
+      send: async (id, event, eventData) => {
+        throwIfNoStateMachine();
+        return resource._stateMachine.send(id, event, eventData);
+      },
+      /**
+       * Get current state of an entity
+       * @param {string} id - Entity ID
+       * @returns {Promise<string>} Current state
+       * @example
+       * const currentState = await orders.state.get('order-123');
+       */
+      get: async (id) => {
+        throwIfNoStateMachine();
+        return resource._stateMachine.getState(id);
+      },
+      /**
+       * Check if a transition is valid
+       * @param {string} id - Entity ID
+       * @param {string} event - Event name
+       * @returns {Promise<boolean>} True if transition is valid
+       * @example
+       * const canConfirm = await orders.state.canTransition('order-123', 'CONFIRM');
+       */
+      canTransition: async (id, event) => {
+        throwIfNoStateMachine();
+        return resource._stateMachine.canTransition(id, event);
+      },
+      /**
+       * Get all valid events for the current state
+       * @param {string} id - Entity ID
+       * @returns {Promise<Array<string>>} Array of valid event names
+       * @example
+       * const events = await orders.state.getValidEvents('order-123');
+       * // Returns: ['SHIP', 'CANCEL']
+       */
+      getValidEvents: async (id) => {
+        throwIfNoStateMachine();
+        return resource._stateMachine.getValidEvents(id);
+      },
+      /**
+       * Initialize entity with initial state
+       * @param {string} id - Entity ID
+       * @param {Object} [context] - Initial context data
+       * @returns {Promise<void>}
+       * @example
+       * await orders.state.initialize('order-456', { customerId: 'user-123' });
+       */
+      initialize: async (id, context) => {
+        throwIfNoStateMachine();
+        return resource._stateMachine.initializeEntity(id, context);
+      },
+      /**
+       * Get transition history for an entity
+       * @param {string} id - Entity ID
+       * @param {Object} [options] - Query options
+       * @param {number} [options.limit=100] - Maximum number of transitions
+       * @param {Date} [options.fromDate] - Filter from date
+       * @param {Date} [options.toDate] - Filter to date
+       * @returns {Promise<Array<Object>>} Transition history
+       * @example
+       * const history = await orders.state.history('order-123', { limit: 50 });
+       */
+      history: async (id, options) => {
+        throwIfNoStateMachine();
+        return resource._stateMachine.getTransitionHistory(id, options);
+      }
+    };
+  }
+  /**
+   * Internal method to attach state machine instance
+   * This is called by StateMachinePlugin during initialization
+   * @private
+   * @param {Object} stateMachine - State machine instance
+   */
+  _attachStateMachine(stateMachine) {
+    this._stateMachine = stateMachine;
+  }
 }
 function validateResourceConfig(config) {
   const errors = [];
@@ -26070,7 +26182,7 @@ class Database extends EventEmitter {
     })();
     this.version = "1";
     this.s3dbVersion = (() => {
-      const [ok, err, version] = tryFn(() => true ? "13.2.1" : "latest");
+      const [ok, err, version] = tryFn(() => true ? "13.3.0" : "latest");
       return ok ? version : "latest";
     })();
     this._resourcesMap = {};
@@ -26915,7 +27027,7 @@ class Database extends EventEmitter {
       if (!existingVersionData || existingVersionData.hash !== newHash) {
         await this.uploadMetadataFile();
       }
-      this.emit("db:resource:updated", name);
+      this.emit("s3db.resourceUpdated", name);
       return existingResource;
     }
     const existingMetadata = this.savedMetadata?.resources?.[name];
@@ -26952,7 +27064,7 @@ class Database extends EventEmitter {
       this._applyMiddlewares(resource, middlewares);
     }
     await this.uploadMetadataFile();
-    this.emit("db:resource:created", name);
+    this.emit("s3db.resourceCreated", name);
     return resource;
   }
   /**
@@ -27078,6 +27190,7 @@ class Database extends EventEmitter {
     return !!this.savedMetadata;
   }
   async disconnect() {
+    await this.emit("disconnected", /* @__PURE__ */ new Date());
     await tryFn(async () => {
       if (this.pluginList && this.pluginList.length > 0) {
         for (const plugin of this.pluginList) {
@@ -27228,7 +27341,7 @@ class Database extends EventEmitter {
     for (const hook of hooks) {
       const [ok, error] = await tryFn(() => hook({ database: this, ...context }));
       if (!ok) {
-        this.emit("db:hook-error", { event, error, context });
+        this.emit("hookError", { event, error, context });
         if (this.strictHooks) {
           throw new DatabaseError(`Hook execution failed for event '${event}': ${error.message}`, {
             event,
@@ -27787,7 +27900,7 @@ class SqsReplicator extends BaseReplicator {
         region: this.region,
         credentials: this.config.credentials
       });
-      this.emit("initialized", {
+      this.emit("db:plugin:initialized", {
         replicator: this.name,
         queueUrl: this.queueUrl,
         queues: this.queues,
@@ -27817,7 +27930,7 @@ class SqsReplicator extends BaseReplicator {
         });
         const result2 = await this.sqsClient.send(command);
         results.push({ queueUrl, messageId: result2.MessageId });
-        this.emit("replicated", {
+        this.emit("plg:replicator:replicated", {
           replicator: this.name,
           resource,
           operation,
@@ -27833,7 +27946,7 @@ class SqsReplicator extends BaseReplicator {
     if (this.config.verbose) {
       console.warn(`[SqsReplicator] Replication failed for ${resource}: ${err.message}`);
     }
-    this.emit("replicator_error", {
+    this.emit("plg:replicator:error", {
       replicator: this.name,
       resource,
       operation,
@@ -28230,7 +28343,7 @@ ${createSQL}`);
       }
     }
     const success = errors.length === 0;
-    this.emit("replicated", {
+    this.emit("plg:replicator:replicated", {
       replicator: this.name,
       resourceName,
       operation,
@@ -28516,7 +28629,7 @@ class WebhookReplicator extends BaseReplicator {
       });
       throw error;
     }
-    this.emit("initialized", {
+    this.emit("db:plugin:initialized", {
       replicator: this.name,
       url: this.url,
       method: this.method,
@@ -28536,7 +28649,7 @@ class WebhookReplicator extends BaseReplicator {
       const payload = this.createPayload(resource, operation, transformedData, id, beforeData);
       const response = await this._makeRequest(payload);
       if (response.success) {
-        this.emit("replicated", {
+        this.emit("plg:replicator:replicated", {
           replicator: this.name,
           resource,
           operation,
@@ -28553,7 +28666,7 @@ class WebhookReplicator extends BaseReplicator {
     if (this.config.verbose) {
       console.warn(`[WebhookReplicator] Replication failed for ${resource}: ${err.message}`);
     }
-    this.emit("replicator_error", {
+    this.emit("plg:replicator:error", {
       replicator: this.name,
       resource,
       operation,
@@ -28832,13 +28945,13 @@ class ReplicatorPlugin extends Plugin {
       }
     };
     this.eventHandlers.set(resource.name, {
-      insert: insertHandler,
-      update: updateHandler,
-      delete: deleteHandler
+      inserted: insertHandler,
+      updated: updateHandler,
+      deleted: deleteHandler
     });
-    resource.on("insert", insertHandler);
-    resource.on("update", updateHandler);
-    resource.on("delete", deleteHandler);
+    resource.on("inserted", insertHandler);
+    resource.on("updated", updateHandler);
+    resource.on("deleted", deleteHandler);
     this.eventListenersInstalled.add(resource.name);
   }
   async onInstall() {
@@ -29228,9 +29341,9 @@ class ReplicatorPlugin extends Plugin {
           const resource = this.database.resources[resourceName];
           const handlers = this.eventHandlers.get(resourceName);
           if (resource && handlers) {
-            resource.off("insert", handlers.insert);
-            resource.off("update", handlers.update);
-            resource.off("delete", handlers.delete);
+            resource.off("inserted", handlers.inserted);
+            resource.off("updated", handlers.updated);
+            resource.off("deleted", handlers.deleted);
           }
         }
       }
@@ -29359,7 +29472,7 @@ class S3QueuePlugin extends Plugin {
         createdAt: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10)
       };
       await plugin.queueResource.insert(queueEntry);
-      plugin.emit("message.enqueued", { id: record.id, queueId: queueEntry.id });
+      plugin.emit("plg:s3-queue:message-enqueued", { id: record.id, queueId: queueEntry.id });
       return record;
     };
     resource.queueStats = async function() {
@@ -30620,6 +30733,7 @@ class StateMachinePlugin extends Plugin {
         // entityId -> currentState
       });
     }
+    await this._attachStateMachinesToResources();
     await this._setupTriggers();
     this.emit("db:plugin:initialized", { machines: Array.from(this.machines.keys()) });
   }
@@ -31461,6 +31575,58 @@ class StateMachinePlugin extends Plugin {
       }
     }
   }
+  /**
+   * Attach state machine instances to their associated resources
+   * This enables the resource API: resource.state(id, event)
+   * @private
+   */
+  async _attachStateMachinesToResources() {
+    for (const [machineName, machineConfig] of Object.entries(this.config.stateMachines)) {
+      const resourceConfig = machineConfig.config || machineConfig;
+      if (!resourceConfig.resource) {
+        if (this.config.verbose) {
+          console.log(`[StateMachinePlugin] Machine '${machineName}' has no resource configured, skipping attachment`);
+        }
+        continue;
+      }
+      let resource;
+      if (typeof resourceConfig.resource === "string") {
+        resource = this.database.resources[resourceConfig.resource];
+        if (!resource) {
+          console.warn(
+            `[StateMachinePlugin] Resource '${resourceConfig.resource}' not found for machine '${machineName}'. Resource API will not be available.`
+          );
+          continue;
+        }
+      } else {
+        resource = resourceConfig.resource;
+      }
+      const machineProxy = {
+        send: async (id, event, eventData) => {
+          return this.send(machineName, id, event, eventData);
+        },
+        getState: async (id) => {
+          return this.getState(machineName, id);
+        },
+        canTransition: async (id, event) => {
+          return this.canTransition(machineName, id, event);
+        },
+        getValidEvents: async (id) => {
+          return this.getValidEvents(machineName, id);
+        },
+        initializeEntity: async (id, context) => {
+          return this.initializeEntity(machineName, id, context);
+        },
+        getTransitionHistory: async (id, options) => {
+          return this.getTransitionHistory(machineName, id, options);
+        }
+      };
+      resource._attachStateMachine(machineProxy);
+      if (this.config.verbose) {
+        console.log(`[StateMachinePlugin] Attached machine '${machineName}' to resource '${resource.name}'`);
+      }
+    }
+  }
   async start() {
     if (this.config.verbose) {
       console.log(`[StateMachinePlugin] Started with ${this.machines.size} state machines`);
@@ -43725,6 +43891,7 @@ class MemoryClient extends EventEmitter {
     const commandName = command.constructor.name;
     const input = command.input || {};
     this.emit("cl:request", commandName, input);
+    this.emit("command.request", commandName, input);
     let response;
     try {
       switch (commandName) {
@@ -43753,6 +43920,7 @@ class MemoryClient extends EventEmitter {
           throw new Error(`Unsupported command: ${commandName}`);
       }
       this.emit("cl:response", commandName, response, input);
+      this.emit("command.response", commandName, response, input);
       return response;
     } catch (error) {
       const mappedError = mapAwsError(error, {
@@ -44048,13 +44216,13 @@ class MemoryClient extends EventEmitter {
     if (keys.length > 0) {
       const result = await this.deleteObjects(keys);
       totalDeleted = result.Deleted.length;
-      this.emit("cl:DeleteAll", {
+      this.emit("deleteAll", {
         prefix,
         batch: totalDeleted,
         total: totalDeleted
       });
     }
-    this.emit("cl:DeleteAllComplete", {
+    this.emit("deleteAllComplete", {
       prefix,
       totalDeleted
     });
@@ -44101,7 +44269,7 @@ class MemoryClient extends EventEmitter {
         });
       }
     }
-    this.emit("cl:MoveAllObjects", { results, errors }, { prefixFrom, prefixTo });
+    this.emit("moveAllObjects", { results, errors });
     if (errors.length > 0) {
       const error = new Error("Some objects could not be moved");
       error.context = {