@sneat/logging 0.1.0

package/eslint.config.js

@@ -0,0 +1,7 @@
+const baseConfig = require('../../eslint.config.js');
+const { sneatLibConfig } = require('../../eslint.lib.config.js');
+
+module.exports = [
+  ...baseConfig,
+  ...sneatLibConfig(__dirname),
+];

package/ng-package.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/libs/logging",
+  "lib": {
+    "entryFile": "src/index.ts"
+  }
+}

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@sneat/logging",
+  "version": "0.1.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@angular/common": ">=21.0.0",
+    "@angular/core": ">=21.0.0",
+    "firebase": "*",
+    "@angular/fire": ">=20",
+    "@sentry/angular": "*",
+    "posthog-js": "*"
+  },
+  "dependencies": {
+    "tslib": "2.8.1"
+  }
+}

package/project.json

@@ -0,0 +1,38 @@
+{
+  "name": "logging",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "projectType": "library",
+  "sourceRoot": "libs/logging/src",
+  "prefix": "sneat",
+  "targets": {
+    "build": {
+      "executor": "@nx/angular:ng-packagr-lite",
+      "outputs": [
+        "{workspaceRoot}/dist/libs/logging"
+      ],
+      "options": {
+        "project": "libs/logging/ng-package.json",
+        "tsConfig": "libs/logging/tsconfig.lib.json"
+      },
+      "configurations": {
+        "production": {
+          "tsConfig": "libs/logging/tsconfig.lib.prod.json"
+        },
+        "development": {}
+      },
+      "defaultConfiguration": "production"
+    },
+    "test": {
+      "executor": "@nx/vitest:test",
+      "outputs": [
+        "{workspaceRoot}/coverage/libs/logging"
+      ],
+      "options": {
+        "tsConfig": "libs/logging/tsconfig.spec.json"
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint"
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './lib/sentry-setup';
+export * from './lib/sneat-logging.module';
+export * from './lib/anaylytics';

package/src/lib/anaylytics/analytics.service.spec.ts

@@ -0,0 +1,35 @@
+import { MultiAnalyticsService } from './multi-analytics.service';
+import { IAnalyticsService } from '@sneat/core';
+
+describe('MultiAnalyticsService', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('should be created', () => {
+    const service = new MultiAnalyticsService([]);
+    expect(service).toBeTruthy();
+  });
+
+  it('should call all analytics services on logEvent', () => {
+    const mockService: IAnalyticsService = {
+      logEvent: vi.fn(),
+      identify: vi.fn(),
+      loggedOut: vi.fn(),
+      setCurrentScreen: vi.fn(),
+    };
+    const service = new MultiAnalyticsService([mockService]);
+    service.logEvent('test_event');
+    // logEvent uses setTimeout in MultiAnalyticsService
+    vi.runAllTimers();
+    expect(mockService.logEvent).toHaveBeenCalledWith(
+      'test_event',
+      undefined,
+      undefined,
+    );
+  });
+});

package/src/lib/anaylytics/fire-analytics.service.spec.ts

@@ -0,0 +1,245 @@
+import { TestBed } from '@angular/core/testing';
+import { Analytics, logEvent, setUserId, setUserProperties } from '@angular/fire/analytics';
+import { ErrorLogger, IErrorLogger } from '@sneat/core';
+import { FireAnalyticsService } from './fire-analytics.service';
+
+vi.mock('@angular/fire/analytics', () => ({
+  Analytics: class {},
+  logEvent: vi.fn(),
+  setUserId: vi.fn(),
+  setUserProperties: vi.fn(),
+}));
+
+describe('FireAnalyticsService', () => {
+  let service: FireAnalyticsService;
+  let errorLogger: IErrorLogger;
+  let analytics: Analytics;
+
+  beforeEach(() => {
+    errorLogger = { 
+      logError: vi.fn(), 
+      logErrorHandler: () => vi.fn() 
+    };
+    analytics = {} as Analytics;
+
+    TestBed.configureTestingModule({
+      providers: [
+        FireAnalyticsService,
+        {
+          provide: ErrorLogger,
+          useValue: errorLogger,
+        },
+        {
+          provide: Analytics,
+          useValue: analytics,
+        },
+      ],
+    });
+    service = TestBed.inject(FireAnalyticsService);
+    vi.clearAllMocks();
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  describe('constructor', () => {
+    it('should log error if errorLogger is not provided', () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+      TestBed.resetTestingModule();
+      TestBed.configureTestingModule({
+        providers: [
+          FireAnalyticsService,
+          {
+            provide: ErrorLogger,
+            useValue: null,
+          },
+          {
+            provide: Analytics,
+            useValue: analytics,
+          },
+        ],
+      });
+      TestBed.inject(FireAnalyticsService);
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining('!errorLogger')
+      );
+      consoleSpy.mockRestore();
+    });
+
+    it('should log error if analytics is not provided', () => {
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+      TestBed.resetTestingModule();
+      TestBed.configureTestingModule({
+        providers: [
+          FireAnalyticsService,
+          {
+            provide: ErrorLogger,
+            useValue: errorLogger,
+          },
+          {
+            provide: Analytics,
+            useValue: null,
+          },
+        ],
+      });
+      TestBed.inject(FireAnalyticsService);
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining('!analytics')
+      );
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('logEvent', () => {
+    it('should call Firebase logEvent with event name and params', () => {
+      const eventName = 'test_event';
+      const eventParams = { param1: 'value1' };
+      const options = { some: 'option' };
+      
+      service.logEvent(eventName, eventParams, options);
+      
+      expect(logEvent).toHaveBeenCalledWith(analytics, eventName, eventParams, options);
+    });
+
+    it('should log error if logEvent throws', () => {
+      const error = new Error('logEvent failed');
+      vi.mocked(logEvent).mockImplementationOnce(() => {
+        throw error;
+      });
+
+      service.logEvent('test_event');
+
+      expect(errorLogger.logError).toHaveBeenCalledWith(
+        error,
+        'Failed to log event to Firebase analytics',
+        { show: false, feedback: false }
+      );
+    });
+  });
+
+  describe('setCurrentScreen', () => {
+    it('should call Firebase logEvent with $screen_view', () => {
+      const screenName = 'HomeScreen';
+      const options = { some: 'option' };
+      
+      service.setCurrentScreen(screenName, options);
+      
+      expect(logEvent).toHaveBeenCalledWith(
+        analytics,
+        '$screen_view',
+        { screenName: screenName },
+        options
+      );
+    });
+
+    it('should log error if logEvent throws', () => {
+      const error = new Error('logEvent failed');
+      vi.mocked(logEvent).mockImplementationOnce(() => {
+        throw error;
+      });
+
+      service.setCurrentScreen('HomeScreen');
+
+      expect(errorLogger.logError).toHaveBeenCalledWith(
+        error,
+        'Failed to log screen view to Firebase analytics',
+        { show: false, feedback: false }
+      );
+    });
+  });
+
+  describe('identify', () => {
+    it('should call setUserId with userID', () => {
+      const userID = 'user123';
+      
+      service.identify(userID);
+      
+      expect(setUserId).toHaveBeenCalledWith(analytics, userID);
+    });
+
+    it('should log error if setUserId throws', () => {
+      const error = new Error('setUserId failed');
+      vi.mocked(setUserId).mockImplementationOnce(() => {
+        throw error;
+      });
+
+      service.identify('user123');
+
+      expect(errorLogger.logError).toHaveBeenCalledWith(
+        error,
+        'Failed to set user id in Firebase analytics',
+        { show: false, feedback: false }
+      );
+    });
+
+    it('should call setUserProperties with userPropertiesToSet', () => {
+      const userID = 'user123';
+      const userPropsToSet = { name: 'John', age: 30 };
+      
+      service.identify(userID, userPropsToSet);
+      
+      expect(setUserProperties).toHaveBeenCalledWith(analytics, userPropsToSet);
+    });
+
+    it('should call setUserProperties with userPropertiesToSetOnce', () => {
+      const userID = 'user123';
+      const userPropsToSetOnce = { email: 'john@test.com' };
+      
+      service.identify(userID, undefined, userPropsToSetOnce);
+      
+      expect(setUserProperties).toHaveBeenCalledWith(analytics, userPropsToSetOnce);
+    });
+
+    it('should merge userPropertiesToSet and userPropertiesToSetOnce', () => {
+      const userID = 'user123';
+      const userPropsToSet = { name: 'John' };
+      const userPropsToSetOnce = { email: 'john@test.com' };
+      
+      service.identify(userID, userPropsToSet, userPropsToSetOnce);
+      
+      expect(setUserProperties).toHaveBeenCalledWith(analytics, {
+        name: 'John',
+        email: 'john@test.com',
+      });
+    });
+
+    it('should log error if setUserProperties throws', () => {
+      const error = new Error('setUserProperties failed');
+      vi.mocked(setUserProperties).mockImplementationOnce(() => {
+        throw error;
+      });
+
+      service.identify('user123', { name: 'John' });
+
+      expect(errorLogger.logError).toHaveBeenCalledWith(
+        error,
+        'Failed to set user props in Firebase analytics',
+        { show: false, feedback: false }
+      );
+    });
+  });
+
+  describe('loggedOut', () => {
+    it('should call setUserId with null', () => {
+      service.loggedOut();
+      
+      expect(setUserId).toHaveBeenCalledWith(analytics, null);
+    });
+
+    it('should log error if setUserId throws', () => {
+      const error = new Error('setUserId failed');
+      vi.mocked(setUserId).mockImplementationOnce(() => {
+        throw error;
+      });
+
+      service.loggedOut();
+
+      expect(errorLogger.logError).toHaveBeenCalledWith(
+        error,
+        'Failed to logout user from Firebase analytics',
+        { show: false, feedback: false }
+      );
+    });
+  });
+});

package/src/lib/anaylytics/fire-analytics.service.ts

@@ -0,0 +1,92 @@
+import { inject, Injectable } from '@angular/core';
+import {
+  Analytics,
+  logEvent,
+  setUserId,
+  setUserProperties,
+} from '@angular/fire/analytics';
+import { ErrorLogger, IErrorLogger, ILogErrorOptions } from '@sneat/core';
+import {
+  IAnalyticsCallOptions,
+  IAnalyticsService,
+  UserProperties,
+} from '@sneat/core';
+
+const logErrOptions: ILogErrorOptions = { show: false, feedback: false };
+
+@Injectable()
+export class FireAnalyticsService implements IAnalyticsService {
+  private readonly errorLogger = inject<IErrorLogger>(ErrorLogger);
+  private readonly analytics = inject(Analytics);
+
+  constructor() {
+    if (!this.errorLogger) {
+      console.error(`FireAnalyticsService() - !errorLogger`);
+    }
+    if (!this.analytics) {
+      console.error(`FireAnalyticsService() - !analytics`);
+    }
+  }
+
+  private readonly logError = (e: unknown, m: string) =>
+    this.errorLogger.logError(e, m, logErrOptions);
+
+  public logEvent(
+    eventName: string,
+    eventParams?: Record<string, unknown>,
+    options?: IAnalyticsCallOptions,
+  ): void {
+    try {
+      logEvent(this.analytics, eventName, eventParams, options);
+    } catch (e) {
+      this.logError(e, 'Failed to log event to Firebase analytics');
+    }
+  }
+
+  public setCurrentScreen(
+    screenName: string,
+    options?: IAnalyticsCallOptions,
+  ): void {
+    try {
+      const args = { screenName: screenName };
+      logEvent(this.analytics, '$screen_view', args, options);
+    } catch (e) {
+      this.logError(e, 'Failed to log screen view to Firebase analytics');
+    }
+  }
+
+  public identify(
+    userID: string,
+    userPropertiesToSet?: UserProperties,
+    userPropertiesToSetOnce?: UserProperties,
+  ): void {
+    try {
+      setUserId(this.analytics, userID);
+    } catch (e) {
+      this.logError(e, 'Failed to set user id in Firebase analytics');
+    }
+    const customProperties: { [id: string]: unknown } = {};
+
+    if (userPropertiesToSet)
+      Object.keys(userPropertiesToSet).forEach(
+        (k) => (customProperties[k] = userPropertiesToSet[k]),
+      );
+    if (userPropertiesToSetOnce)
+      Object.keys(userPropertiesToSetOnce).forEach(
+        (k) => (customProperties[k] = userPropertiesToSetOnce[k]),
+      );
+    try {
+      setUserProperties(this.analytics, customProperties);
+    } catch (e) {
+      this.logError(e, 'Failed to set user props in Firebase analytics');
+    }
+  }
+
+  public loggedOut(): void {
+    try {
+      setUserId(this.analytics, null);
+    } catch (e) {
+      this.logError(e, 'Failed to logout user from Firebase analytics');
+    }
+  }
+}

package/src/lib/anaylytics/index.ts

@@ -0,0 +1 @@
+export * from './provide-sneat-analytics';

package/src/lib/anaylytics/multi-analytics.service.spec.ts

@@ -0,0 +1,112 @@
+import { MultiAnalyticsService } from './multi-analytics.service';
+import { IAnalyticsService } from '@sneat/core';
+
+describe('MultiAnalyticsService', () => {
+  let mockAnalyticsService1: IAnalyticsService;
+  let mockAnalyticsService2: IAnalyticsService;
+  let service: MultiAnalyticsService;
+
+  beforeEach(() => {
+    mockAnalyticsService1 = {
+      identify: vi.fn(),
+      logEvent: vi.fn(),
+      setCurrentScreen: vi.fn(),
+      loggedOut: vi.fn(),
+    };
+
+    mockAnalyticsService2 = {
+      identify: vi.fn(),
+      logEvent: vi.fn(),
+      setCurrentScreen: vi.fn(),
+      loggedOut: vi.fn(),
+    };
+
+    service = new MultiAnalyticsService([
+      mockAnalyticsService1,
+      mockAnalyticsService2,
+    ]);
+  });
+
+  it('should create', () => {
+    expect(new MultiAnalyticsService([])).toBeTruthy();
+  });
+
+  describe('identify', () => {
+    it('should call identify on all analytics services', () => {
+      vi.useFakeTimers();
+      const userID = 'user123';
+      const userProps = { name: 'John' };
+      const userPropsOnce = { email: 'john@test.com' };
+
+      service.identify(userID, userProps, userPropsOnce);
+      vi.runAllTimers();
+
+      expect(mockAnalyticsService1.identify).toHaveBeenCalledWith(
+        userID,
+        userProps,
+        userPropsOnce,
+      );
+      expect(mockAnalyticsService2.identify).toHaveBeenCalledWith(
+        userID,
+        userProps,
+        userPropsOnce,
+      );
+      vi.useRealTimers();
+    });
+  });
+
+  describe('logEvent', () => {
+    it('should call logEvent on all analytics services', () => {
+      vi.useFakeTimers();
+      const eventName = 'test_event';
+      const eventParams = { param1: 'value1' };
+      const options = { some: 'option' };
+
+      service.logEvent(eventName, eventParams, options);
+      vi.runAllTimers();
+
+      expect(mockAnalyticsService1.logEvent).toHaveBeenCalledWith(
+        eventName,
+        eventParams,
+        options,
+      );
+      expect(mockAnalyticsService2.logEvent).toHaveBeenCalledWith(
+        eventName,
+        eventParams,
+        options,
+      );
+      vi.useRealTimers();
+    });
+  });
+
+  describe('setCurrentScreen', () => {
+    it('should call setCurrentScreen on all analytics services', () => {
+      const screenName = 'HomeScreen';
+      const options = { some: 'option' };
+
+      service.setCurrentScreen(screenName, options);
+
+      expect(mockAnalyticsService1.setCurrentScreen).toHaveBeenCalledWith(
+        screenName,
+        options,
+      );
+      expect(mockAnalyticsService2.setCurrentScreen).toHaveBeenCalledWith(
+        screenName,
+        options,
+      );
+    });
+  });
+
+  describe('loggedOut', () => {
+    it('should call loggedOut on all analytics services', () => {
+      vi.useFakeTimers();
+
+      service.loggedOut();
+      vi.runAllTimers();
+
+      expect(mockAnalyticsService1.loggedOut).toHaveBeenCalled();
+      expect(mockAnalyticsService2.loggedOut).toHaveBeenCalled();
+      vi.useRealTimers();
+    });
+  });
+});

package/src/lib/anaylytics/multi-analytics.service.ts

@@ -0,0 +1,47 @@
+import {
+  IAnalyticsCallOptions,
+  IAnalyticsService,
+  UserProperties,
+} from '@sneat/core';
+
+const prefix = 'MultiAnalyticsService.';
+
+export class MultiAnalyticsService implements IAnalyticsService {
+  constructor(private readonly as: readonly IAnalyticsService[]) {
+    console.log(
+      prefix +
+        `.constructor() as=[${as.map((a) => a.constructor.name).join(',')}]`,
+    );
+  }
+
+  public identify(
+    userID: string,
+    userPropsToSet?: UserProperties,
+    userPropsToSetOnce?: UserProperties,
+  ): void {
+    this.as.forEach((as) =>
+      setTimeout(() => as.identify(userID, userPropsToSet, userPropsToSetOnce)),
+    );
+  }
+
+  public logEvent(
+    eventName: string,
+    eventParams?: Readonly<Record<string, unknown>>,
+    options?: IAnalyticsCallOptions,
+  ): void {
+    this.as.forEach((as) =>
+      setTimeout(() => as.logEvent(eventName, eventParams, options)),
+    );
+  }
+
+  public setCurrentScreen(
+    screenName: string,
+    options?: IAnalyticsCallOptions,
+  ): void {
+    this.as.forEach((as) => as.setCurrentScreen(screenName, options));
+  }
+
+  public loggedOut(): void {
+    this.as.forEach((as) => setTimeout(() => as.loggedOut()));
+  }
+}