fauxbase 0.4.0 → 0.5.1

package/dist/index.cjs

@@ -183,6 +183,8 @@ var Service = class {
   driver;
   resourceName;
   client;
+  /** @internal */
+  _eventBus;
   /** @internal — called by createClient to wire the service */
   _init(driver, resourceName) {
     this.driver = driver;
@@ -203,27 +205,56 @@ var Service = class {
     await this.runHooks("beforeCreate", data, allItems);
     const result = await this.driver.create(this.resourceName, data);
     await this.runHooks("afterCreate", result.data);
+    this.emitEvent("created", { data: result.data, id: result.data.id });
     return result;
   }
   async update(id, data) {
     await this.runHooks("beforeUpdate", id, data);
     const result = await this.driver.update(this.resourceName, id, data);
     await this.runHooks("afterUpdate", result.data);
+    this.emitEvent("updated", { data: result.data, id });
     return result;
   }
   async delete(id) {
-    return this.driver.delete(this.resourceName, id);
+    const result = await this.driver.delete(this.resourceName, id);
+    this.emitEvent("deleted", { data: result.data, id });
+    return result;
   }
   async count(filter) {
     return this.driver.count(this.resourceName, filter);
   }
   get bulk() {
+    const self = this;
     return {
-      create: (items) => this.driver.bulkCreate(this.resourceName, items),
-      update: (updates) => this.driver.bulkUpdate(this.resourceName, updates),
-      delete: (ids) => this.driver.bulkDelete(this.resourceName, ids)
+      async create(items) {
+        const result = await self.driver.bulkCreate(self.resourceName, items);
+        self.emitEvent("bulkCreated", { data: result.data });
+        return result;
+      },
+      async update(updates) {
+        const result = await self.driver.bulkUpdate(self.resourceName, updates);
+        self.emitEvent("bulkUpdated", { data: result.data, ids: updates.map((u) => u.id) });
+        return result;
+      },
+      async delete(ids) {
+        const result = await self.driver.bulkDelete(self.resourceName, ids);
+        self.emitEvent("bulkDeleted", { ids });
+        return result;
+      }
     };
   }
+  emitEvent(action, extra) {
+    if (!this._eventBus) return;
+    this._eventBus.emit({
+      action,
+      resource: this.resourceName,
+      data: extra.data,
+      id: extra.id,
+      ids: extra.ids,
+      timestamp: Date.now(),
+      source: "local"
+    });
+  }
   async runHooks(hookType, ...args) {
     const methods = getHooks(this.constructor, hookType);
     for (const methodName of methods) {
@@ -1360,6 +1391,146 @@ var HttpDriver = class {
   }
 };
 
+// src/events/event-bus.ts
+var EventBus = class {
+  listeners = /* @__PURE__ */ new Map();
+  anyListeners = /* @__PURE__ */ new Set();
+  on(resource, handler) {
+    if (!this.listeners.has(resource)) {
+      this.listeners.set(resource, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(resource).add(handler);
+    return () => {
+      this.listeners.get(resource)?.delete(handler);
+    };
+  }
+  onAny(handler) {
+    this.anyListeners.add(handler);
+    return () => {
+      this.anyListeners.delete(handler);
+    };
+  }
+  emit(event) {
+    const resourceListeners = this.listeners.get(event.resource);
+    if (resourceListeners) {
+      for (const handler of resourceListeners) {
+        handler(event);
+      }
+    }
+    for (const handler of this.anyListeners) {
+      handler(event);
+    }
+  }
+  destroy() {
+    this.listeners.clear();
+    this.anyListeners.clear();
+  }
+};
+
+// src/events/sse-source.ts
+var SSESource = class {
+  constructor(config, eventBus) {
+    this.config = config;
+    this.eventBus = eventBus;
+  }
+  eventSource = null;
+  connect() {
+    this.eventSource = new EventSource(this.config.url, {
+      withCredentials: this.config.withCredentials
+    });
+    for (const [eventType, resource] of Object.entries(this.config.eventMap)) {
+      this.eventSource.addEventListener(eventType, (e) => {
+        const parsed = this.parseEvent(e, resource);
+        if (parsed) {
+          this.eventBus.emit(parsed);
+        }
+      });
+    }
+  }
+  disconnect() {
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+  }
+  parseEvent(e, resource) {
+    try {
+      const raw = JSON.parse(e.data);
+      return {
+        action: raw.action,
+        resource,
+        data: raw.data,
+        id: raw.id,
+        ids: raw.ids,
+        timestamp: raw.timestamp ?? Date.now(),
+        source: "remote"
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/events/stomp-source.ts
+var STOMPSource = class {
+  constructor(config, eventBus) {
+    this.config = config;
+    this.eventBus = eventBus;
+  }
+  client = null;
+  connect() {
+    this.connectAsync();
+  }
+  async connectAsync() {
+    let StompJs;
+    try {
+      const moduleName = "@stomp/stompjs";
+      StompJs = await Function("m", "return import(m)")(moduleName);
+    } catch {
+      throw new Error(
+        "STOMP source requires @stomp/stompjs. Install it: npm install @stomp/stompjs"
+      );
+    }
+    this.client = new StompJs.Client({
+      brokerURL: this.config.brokerUrl,
+      connectHeaders: this.config.connectHeaders,
+      onConnect: () => {
+        for (const [destination, resource] of Object.entries(this.config.subscriptions)) {
+          this.client.subscribe(destination, (message) => {
+            const parsed = this.parseMessage(message, resource);
+            if (parsed) {
+              this.eventBus.emit(parsed);
+            }
+          });
+        }
+      }
+    });
+    this.client.activate();
+  }
+  disconnect() {
+    if (this.client) {
+      this.client.deactivate();
+      this.client = null;
+    }
+  }
+  parseMessage(message, resource) {
+    try {
+      const raw = JSON.parse(message.body);
+      return {
+        action: raw.action,
+        resource,
+        data: raw.data,
+        id: raw.id,
+        ids: raw.ids,
+        timestamp: raw.timestamp ?? Date.now(),
+        source: "remote"
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+
 // src/seed.ts
 function seed(entityClass, data) {
   const entityName = entityClass.name.toLowerCase();
@@ -1458,6 +1629,33 @@ function createClient(config) {
       svc._setClient(client);
     }
   }
+  let eventSource = null;
+  if (config.events) {
+    const eventBus = new EventBus();
+    client._eventBus = eventBus;
+    for (const [name, ServiceClass] of Object.entries(config.services)) {
+      const svc = client[name];
+      svc._eventBus = eventBus;
+    }
+    const eventsConfig = config.events === true ? {} : config.events;
+    if (eventsConfig.handlers) {
+      for (const [resource, handler] of Object.entries(eventsConfig.handlers)) {
+        eventBus.on(resource, handler);
+      }
+    }
+    if (eventsConfig.source) {
+      if (eventsConfig.source.type === "sse") {
+        eventSource = new SSESource(eventsConfig.source, eventBus);
+      } else if (eventsConfig.source.type === "stomp") {
+        eventSource = new STOMPSource(eventsConfig.source, eventBus);
+      }
+      eventSource?.connect();
+    }
+    client.disconnect = () => {
+      eventSource?.disconnect();
+      eventBus.destroy();
+    };
+  }
   let readyPromise;
   if (defaultDriver instanceof LocalDriver) {
     if (defaultDriver.isReady) {
@@ -1506,6 +1704,7 @@ function applySeedsIfNeeded(driver, seeds) {
 exports.AuthService = AuthService;
 exports.ConflictError = ConflictError;
 exports.Entity = Entity;
+exports.EventBus = EventBus;
 exports.FauxbaseError = FauxbaseError;
 exports.ForbiddenError = ForbiddenError;
 exports.HttpDriver = HttpDriver;