feat: no-op event methods when events are disabled instead of throwing

Author: Zaimwa9

flagsmith-core.ts

@@ -947,24 +947,18 @@ const Flagsmith = class {
         this.updateEventStorage();
     };
 
-    private requireEventProcessor(): EventProcessor {
-        if (!this.eventProcessor) {
-            throw new Error('Flagsmith: events must be enabled (enableEvents: true) to use this method.');
-        }
-        return this.eventProcessor;
-    }
-
     trackEvent = (event: string, opts?: {
         identifier?: string | null;
         value?: IFlagsmithValue;
         traits?: ITraits;
         metadata?: Record<string, unknown>;
     }) => {
-        const processor = this.requireEventProcessor();
+        // No-op when events are disabled, mirroring enableAnalytics: false.
+        if (!this.eventProcessor) return;
         if (event.startsWith('$')) {
             throw new Error(`Flagsmith: event names starting with "$" are reserved; use trackExposureEvent to record "${FLAG_EXPOSURE_EVENT}".`);
         }
-        processor.trackEvent({
+        this.eventProcessor.trackEvent({
             event,
             identifier: opts?.identifier ?? this.evaluationContext.identity?.identifier ?? null,
             value: opts?.value ?? null,
@@ -979,8 +973,9 @@ const Flagsmith = class {
         traits?: ITraits;
         metadata?: Record<string, unknown>;
     }) => {
-        const processor = this.requireEventProcessor();
-        processor.trackExposureEvent({
+        // No-op when events are disabled, mirroring enableAnalytics: false.
+        if (!this.eventProcessor) return;
+        this.eventProcessor.trackExposureEvent({
             featureName,
             identifier: opts?.identifier ?? this.evaluationContext.identity?.identifier ?? null,
             value: opts?.value ?? null,
@@ -992,9 +987,10 @@ const Flagsmith = class {
     flushEvents = (): Promise<void> => this.eventProcessor ? this.eventProcessor.flush() : Promise.resolve();
 
     getExperimentFlag = (featureName: string): IFlagsmithFeature | null => {
-        this.requireEventProcessor();
         const key = featureName.toLowerCase().replace(/ /g, '_');
         const flag = (this.flags && this.flags[key]) || null;
+        // When events are disabled this degrades to a plain flag read.
+        if (!this.eventProcessor) return flag;
         const identifier = this.evaluationContext.identity?.identifier;
         if (!identifier) {
             this.log('Flagsmith: getExperimentFlag called without an identity; call identify() (optionally with transient: true) before using experiments to record an exposure. Returning environment flags; no exposure recorded.');

test/events.test.ts

@@ -16,17 +16,22 @@ function eventCalls(mockFetch: jest.Mock) {
 }
 
 describe('events gate', () => {
-    test('trackEvent throws when events are not enabled', async () => {
-        const { flagsmith, initConfig } = getFlagsmith();
+    test('trackEvent is a no-op when events are not enabled', async () => {
+        const { flagsmith, initConfig, mockFetch } = getFlagsmith();
         await flagsmith.init(initConfig);
-        expect(() => flagsmith.trackEvent('purchase')).toThrow(/events must be enabled/i);
+        expect(() => flagsmith.trackEvent('purchase')).not.toThrow();
+        await flagsmith.flushEvents();
+        expect(eventCalls(mockFetch)).toHaveLength(0);
     });
 
-    test('trackExposureEvent and getExperimentFlag throw when not enabled', async () => {
-        const { flagsmith, initConfig } = getFlagsmith();
+    test('trackExposureEvent and getExperimentFlag are no-ops when not enabled', async () => {
+        const { flagsmith, initConfig, mockFetch } = getFlagsmith({ identity: testIdentity });
         await flagsmith.init(initConfig);
-        expect(() => flagsmith.trackExposureEvent('f')).toThrow(/events must be enabled/i);
-        expect(() => flagsmith.getExperimentFlag('f')).toThrow(/events must be enabled/i);
+        expect(() => flagsmith.trackExposureEvent('font_size')).not.toThrow();
+        // getExperimentFlag still returns the flag, just records no exposure.
+        expect(flagsmith.getExperimentFlag('font_size')).toEqual(expect.objectContaining({ value: 16 }));
+        await flagsmith.flushEvents();
+        expect(eventCalls(mockFetch)).toHaveLength(0);
     });
 
     test('eventProcessorConfig without enableEvents throws at init', async () => {

types.d.ts

@@ -291,8 +291,8 @@ T extends string = string
      */
     setTraits: (traits: ITraits) => Promise<void>;
     /**
-     * Record an arbitrary product event (e.g. "purchase"). Requires
-     * enableEvents: true (throws otherwise). identifier/traits default to the
+     * Record an arbitrary product event (e.g. "purchase"). No-op when events
+     * are disabled (enableEvents is not set). identifier/traits default to the
      * current identified context when omitted.
      * @experimental @internal
      */
@@ -304,7 +304,8 @@ T extends string = string
     }) => void;
     /**
      * Record that an identity was exposed to a flag/variant (emits the reserved
-     * "$flag_exposure" event). Requires enableEvents: true (throws otherwise).
+     * "$flag_exposure" event). No-op when events are disabled (enableEvents is
+     * not set).
      * @experimental @internal
      */
     trackExposureEvent: (featureName: string, opts?: {
@@ -316,7 +317,8 @@ T extends string = string
     /**
      * Resolve a flag for the currently identified user and fire one
      * "$flag_exposure" event (skipped unless flags were loaded from the server
-     * and the feature exists). Requires enableEvents: true (throws otherwise).
+     * and the feature exists). When events are disabled (enableEvents is not
+     * set) this degrades to a plain flag read.
      * @experimental @internal
      */
     getExperimentFlag: (featureName: string) => IFlagsmithFeature | null;