@sneat/logging 0.1.2 → 0.1.4

package/src/lib/analytics/provide-sneat-analytics.ts

@@ -1,68 +0,0 @@
-import { Analytics, getAnalytics } from '@angular/fire/analytics';
-import { FirebaseApp } from '@angular/fire/app';
-import {
-  AnalyticsService,
-  IAnalyticsService,
-  IEnvironmentConfig,
-} from '@sneat/core';
-import { ErrorLogger, IErrorLogger } from '@sneat/core';
-import { FireAnalyticsService } from './fire-analytics.service';
-import { MultiAnalyticsService } from './multi-analytics.service';
-import { PosthogAnalyticsService } from './posthog-analytics.service';
-import { Provider } from '@angular/core';
-
-export interface IAnalyticsConfig {
-  addPosthog?: boolean;
-  addFirebaseAnalytics?: boolean;
-}
-
-function getAnalyticsConfig(
-  environmentConfig: IEnvironmentConfig,
-): IAnalyticsConfig {
-  const useAnalytics =
-    location.host === 'sneat.app' || location.protocol === 'https:';
-
-  const firebaseMeasurementId = environmentConfig.firebaseConfig?.measurementId;
-
-  return {
-    addPosthog: useAnalytics && !!environmentConfig.posthog?.token,
-    addFirebaseAnalytics:
-      useAnalytics &&
-      !!firebaseMeasurementId &&
-      firebaseMeasurementId !== 'G-PROVIDE_IF_NEEDED',
-  };
-}
-
-export function provideSneatAnalytics(
-  environmentConfig: IEnvironmentConfig,
-): Provider {
-  return {
-    provide: AnalyticsService,
-    deps: [
-      ErrorLogger,
-      FirebaseApp,
-      // [new Optional(), Analytics], // TODO: The received Analytics instance does not have app property :(
-    ],
-    useFactory: (errorLogger: IErrorLogger, fbApp: FirebaseApp) => {
-      const config = getAnalyticsConfig(environmentConfig);
-      const as: IAnalyticsService[] = [];
-      if (config?.addPosthog) {
-        as.push(new PosthogAnalyticsService());
-      }
-      if (config?.addFirebaseAnalytics) {
-        const analytics: Analytics = fbApp && getAnalytics(fbApp); // Ideally we would want to get it from the DI
-        if (analytics) {
-          as.push(new FireAnalyticsService());
-          // as.push(new FireAnalyticsService(errorLogger, analytics));
-        } else {
-          errorLogger.logError(
-            'addFirebaseAnalytics==true, but Firebase Analytics is not provided',
-            undefined,
-            { show: false, feedback: false },
-          );
-        }
-      }
-      return new MultiAnalyticsService(as);
-    },
-  };
-}

package/src/lib/error-logger.service.spec.ts

@@ -1,284 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { ErrorLoggerService } from './error-logger.service';
-import { ToastController } from '@ionic/angular/standalone';
-import { captureException, showReportDialog } from '@sentry/angular';
-import { HttpErrorResponse } from '@angular/common/http';
-import { Mock } from 'vitest';
-
-vi.mock('@sentry/angular', () => ({
-  captureException: vi.fn().mockImplementation(() => {
-    return 'event-id';
-  }),
-  showReportDialog: vi.fn(),
-}));
-
-describe('ErrorLoggerService', () => {
-  let service: ErrorLoggerService;
-  let toastController: { create: Mock; dismiss: Mock };
-
-  beforeEach(() => {
-    toastController = {
-      create: vi.fn().mockReturnValue(
-        Promise.resolve({
-          present: vi.fn().mockReturnValue(Promise.resolve()),
-        }),
-      ),
-      dismiss: vi.fn().mockReturnValue(Promise.resolve()),
-    };
-
-    TestBed.configureTestingModule({
-      providers: [
-        ErrorLoggerService,
-        { provide: ToastController, useValue: toastController },
-      ],
-    });
-    service = TestBed.inject(ErrorLoggerService);
-    vi.clearAllMocks();
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-
-  describe('logError', () => {
-    it('should log to console.error', () => {
-      const consoleSpy = vi
-        .spyOn(console, 'error')
-        .mockImplementation(() => undefined);
-      service.logError(new Error('test'));
-      expect(consoleSpy).toHaveBeenCalled();
-    });
-
-    it('should NOT capture exception if on localhost', () => {
-      vi.stubGlobal('location', { hostname: 'localhost' });
-      service.logError(new Error('test'), 'msg', { report: true });
-      expect(captureException).not.toHaveBeenCalled();
-      vi.unstubAllGlobals();
-    });
-
-    it('should capture exception if NOT on localhost', () => {
-      vi.stubGlobal('location', { hostname: 'example.com' });
-      service.logError(new Error('test'), 'msg', { report: true });
-      expect(captureException).toHaveBeenCalled();
-      vi.unstubAllGlobals();
-    });
-
-    it('should show error toast by default', () => {
-      service.logError(new Error('test'));
-      expect(toastController.create).toHaveBeenCalled();
-    });
-
-    it('should handle boolean true value as error', () => {
-      const consoleSpy = vi
-        .spyOn(console, 'error')
-        .mockImplementation(() => undefined);
-      service.logError(true, 'test message');
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Argument exception'),
-        expect.any(Error),
-        undefined,
-      );
-      consoleSpy.mockRestore();
-    });
-
-    it('should handle boolean false value as error', () => {
-      const consoleSpy = vi
-        .spyOn(console, 'error')
-        .mockImplementation(() => undefined);
-      service.logError(false, 'test message');
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Argument exception'),
-        expect.any(Error),
-        undefined,
-      );
-      consoleSpy.mockRestore();
-    });
-
-    it('should not show feedback dialog when feedback is false', () => {
-      vi.stubGlobal('location', { hostname: 'example.com' });
-      service.logError(new Error('test'), 'msg', {
-        report: true,
-        feedback: false,
-      });
-      expect(showReportDialog).not.toHaveBeenCalled();
-      vi.unstubAllGlobals();
-    });
-
-    it('should show feedback dialog by default when capturing', () => {
-      vi.stubGlobal('location', { hostname: 'example.com' });
-      service.logError(new Error('test'), 'msg', { report: true });
-      expect(showReportDialog).toHaveBeenCalledWith({ eventId: 'event-id' });
-      vi.unstubAllGlobals();
-    });
-
-    it('should handle Sentry exception gracefully', () => {
-      vi.stubGlobal('location', { hostname: 'example.com' });
-      const consoleSpy = vi
-        .spyOn(console, 'error')
-        .mockImplementation(() => undefined);
-      vi.mocked(captureException).mockImplementationOnce(() => {
-        throw new Error('Sentry failed');
-      });
-
-      service.logError(new Error('test'), 'msg', { report: true });
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Sentry failed'),
-        expect.any(Error),
-      );
-      consoleSpy.mockRestore();
-      vi.unstubAllGlobals();
-    });
-
-    it('should not show error when show option is false', () => {
-      service.logError(new Error('test'), 'msg', { show: false });
-      expect(toastController.create).not.toHaveBeenCalled();
-    });
-
-    it('should not report error when report option is false', () => {
-      vi.stubGlobal('location', { hostname: 'example.com' });
-      service.logError(new Error('test'), 'msg', { report: false });
-      expect(captureException).not.toHaveBeenCalled();
-      vi.unstubAllGlobals();
-    });
-  });
-
-  describe('showError', () => {
-    it('should show toast with error message', async () => {
-      await service.showError(new Error('test message'));
-      expect(toastController.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          message: 'test message',
-        }),
-      );
-    });
-
-    it('should handle HttpErrorResponse with server message', async () => {
-      const errorResponse = new HttpErrorResponse({
-        error: { error: { message: 'server fail' } },
-      });
-      await service.showError(errorResponse);
-      expect(toastController.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          message: expect.stringContaining('server fail'),
-        }),
-      );
-    });
-
-    it('should throw error if e is null (results in crash/throw)', () => {
-      expect(() => service.showError(null as unknown as string)).toThrow();
-    });
-
-    it('should throw error for negative duration', () => {
-      expect(() => service.showError('test', -1)).toThrow();
-    });
-
-    it('should warn when ToastController is not available', () => {
-      const consoleSpy = vi
-        .spyOn(console, 'warn')
-        .mockImplementation(() => undefined);
-      TestBed.resetTestingModule();
-      TestBed.configureTestingModule({
-        providers: [
-          ErrorLoggerService,
-          { provide: ToastController, useValue: null },
-        ],
-      });
-      const serviceWithoutToast = TestBed.inject(ErrorLoggerService);
-
-      serviceWithoutToast.showError(new Error('test'));
-
-      expect(consoleSpy).toHaveBeenCalledWith(
-        expect.stringContaining('ToastController not available'),
-      );
-      consoleSpy.mockRestore();
-    });
-
-    it('should handle toast present failure', async () => {
-      const presentError = new Error('present failed');
-      toastController.create.mockReturnValue(
-        Promise.resolve({
-          present: vi.fn().mockReturnValue(Promise.reject(presentError)),
-        }),
-      );
-      const logErrorSpy = vi
-        .spyOn(service, 'logError')
-        .mockImplementation(() => undefined);
-
-      await service.showError(new Error('test'));
-
-      // Wait for async operations
-      await new Promise((resolve) => setTimeout(resolve, 0));
-
-      expect(logErrorSpy).toHaveBeenCalledWith(
-        presentError,
-        'Failed to present toast with error message:',
-        { show: false },
-      );
-      logErrorSpy.mockRestore();
-    });
-
-    it('should handle toast creation failure', async () => {
-      const createError = new Error('create failed');
-      toastController.create.mockReturnValue(Promise.reject(createError));
-      const logErrorSpy = vi
-        .spyOn(service, 'logError')
-        .mockImplementation(() => undefined);
-
-      await service.showError(new Error('test'));
-
-      // Wait for async operations
-      await new Promise((resolve) => setTimeout(resolve, 0));
-
-      expect(logErrorSpy).toHaveBeenCalledWith(
-        createError,
-        'Failed to create a toast with error message:',
-        { show: false },
-      );
-      logErrorSpy.mockRestore();
-    });
-
-    it('should handle toast dismiss failure in button handler', async () => {
-      const dismissError = new Error('dismiss failed');
-      toastController.dismiss.mockReturnValue(Promise.reject(dismissError));
-      const logErrorSpy = vi
-        .spyOn(service, 'logError')
-        .mockImplementation(() => undefined);
-
-      await service.showError(new Error('test'));
-
-      const createCall = toastController.create.mock.calls[0][0];
-      const closeButtonHandler = createCall.buttons[0].handler;
-      await closeButtonHandler();
-
-      expect(logErrorSpy).toHaveBeenCalledWith(
-        dismissError,
-        'Failed to dismiss error dialog',
-        { show: false },
-      );
-      logErrorSpy.mockRestore();
-    });
-
-    it('should use custom duration when provided', async () => {
-      const customDuration = 5000;
-      await service.showError(new Error('test'), customDuration);
-
-      expect(toastController.create).toHaveBeenCalledWith(
-        expect.objectContaining({
-          duration: customDuration,
-        }),
-      );
-    });
-  });
-
-  describe('logErrorHandler', () => {
-    it('should return a function that calls logError', () => {
-      const logSpy = vi
-        .spyOn(service, 'logError')
-        .mockImplementation(() => undefined);
-      const handler = service.logErrorHandler('test msg');
-      handler('error');
-      expect(logSpy).toHaveBeenCalledWith('error', 'test msg', undefined);
-    });
-  });
-});

package/src/lib/error-logger.service.ts

@@ -1,131 +0,0 @@
-import { HttpErrorResponse } from '@angular/common/http';
-import { Injectable, Optional } from '@angular/core';
-import { ToastController } from '@ionic/angular/standalone';
-import { captureException, showReportDialog } from '@sentry/angular';
-import { IErrorLogger, ILogErrorOptions } from '@sneat/core';
-
-const defaultErrorToastDuration = 7000;
-
-@Injectable()
-export class ErrorLoggerService implements IErrorLogger {
-  constructor(@Optional() private readonly toastController: ToastController) {}
-
-  public readonly logErrorHandler =
-    (message?: string, options?: ILogErrorOptions) => (e: unknown) =>
-      this.logError(e, message, options);
-
-  public readonly logError = (
-    e: unknown,
-    message?: string,
-    options?: ILogErrorOptions,
-  ): void => {
-    console.error(
-      `ErrorLoggerService.logError: ${message || 'Error'}:`,
-      e,
-      '; Logging options:',
-      options,
-    );
-    if (e === true || e === false) {
-      try {
-        // noinspection ExceptionCaughtLocallyJS
-        throw new Error(`got boolean value as an error: ${e}: ${message}`);
-      } catch (ex) {
-        console.error('Argument exception at logError():', ex, options);
-        return;
-      }
-    }
-    if (options?.report === undefined || options.report) {
-      if (window.location.hostname !== 'localhost') {
-        try {
-          const eventId = message
-            ? captureException(message, { originalException: e })
-            : captureException(e);
-
-          // console.log('Captured error by Sentry with eventId:', eventId);
-          if (options?.feedback === undefined || options.feedback) {
-            showReportDialog({ eventId });
-          }
-        } catch (ex) {
-          console.error(
-            'Sentry failed to capture or show  error report dialog',
-            ex,
-          );
-        }
-      }
-    }
-    if (options?.show || options?.show === undefined) {
-      this.showError(e, options?.showDuration);
-    }
-    return; // return message ? { error: e, message } : e;
-  };
-
-  public showError(e: unknown, duration?: number): void {
-    let clientMessage: string | undefined;
-
-    if ((e as { message?: string }).message) {
-      clientMessage =
-        (clientMessage &&
-          `${clientMessage}: ${(e as { message?: string }).message}`) ||
-        (e as { message?: string }).message;
-    } else if (!clientMessage) {
-      clientMessage = (e as object).toString();
-    }
-    if (!clientMessage) {
-      throw new Error('showError() have not received a message to display');
-    }
-    if (duration && duration < 0) {
-      throw new Error('showError received negative duration');
-    }
-
-    let message = clientMessage;
-
-    let serverMessage: string | undefined;
-    if (e instanceof HttpErrorResponse) {
-      const e2 = e as HttpErrorResponse;
-      serverMessage = e2.error?.error?.message;
-      if (serverMessage) {
-        message += `.\n\nServer returned error message: ${serverMessage}`;
-      }
-    }
-    if (!this.toastController) {
-      console.warn('ToastController not available, cannot show error toast');
-      return;
-    }
-    this.toastController
-      .create({
-        message,
-        duration: duration || defaultErrorToastDuration,
-        keyboardClose: true,
-        buttons: [
-          {
-            icon: 'close',
-            side: 'end',
-            handler: () =>
-              this.toastController.dismiss().catch((e) =>
-                this.logError(e, 'Failed to dismiss error dialog', {
-                  show: false,
-                }),
-              ),
-          },
-        ],
-        color: 'danger',
-        header: 'Something went wrong',
-        position: 'top',
-      })
-      .then((toast) =>
-        toast
-          .present()
-          .catch(
-            this.logErrorHandler(
-              'Failed to present toast with error message:',
-              { show: false },
-            ),
-          ),
-      )
-      .catch(
-        this.logErrorHandler('Failed to create a toast with error message:', {
-          show: false,
-        }),
-      );
-  }
-}

package/src/lib/sentry-setup.ts

@@ -1,32 +0,0 @@
-import { inject, provideAppInitializer, ErrorHandler } from '@angular/core';
-import { TraceService, init, createErrorHandler } from '@sentry/angular';
-import { Router } from '@angular/router';
-import { BrowserOptions } from '@sentry/browser';
-
-export const provideSentryAppInitializer = (options: BrowserOptions) => {
-  initSentry(options);
-  return [
-    ...sentryAppInitializerProviders,
-    provideAppInitializer(() => {
-      inject(TraceService);
-    }),
-  ];
-};
-
-function initSentry(options: BrowserOptions): void {
-  // console.log('initSentry()');
-  init(options);
-}
-
-const sentryAppInitializerProviders = [
-  {
-    provide: TraceService,
-    deps: [Router],
-  },
-  {
-    provide: ErrorHandler,
-    useValue: createErrorHandler({
-      showDialog: true,
-    }),
-  },
-];

package/src/lib/sneat-logging.module.ts

@@ -1,16 +0,0 @@
-import { NgModule, Provider } from '@angular/core';
-import { ErrorLogger } from '@sneat/core';
-import { ErrorLoggerService } from './error-logger.service';
-
-export function provideErrorLogger(): Provider {
-  return {
-    provide: ErrorLogger,
-    useClass: ErrorLoggerService,
-  };
-}
-
-@NgModule({
-  imports: [],
-  providers: [provideErrorLogger()],
-})
-export class SneatLoggingModule {}

package/src/test-setup.ts

@@ -1,3 +0,0 @@
-import { setupTestEnvironment } from '@sneat/core/testing';
-
-setupTestEnvironment();

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../tsconfig.angular.json",
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,19 +0,0 @@
-{
-  "extends": "../../tsconfig.lib.base.json",
-  "exclude": [
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx",
-    "src/test-setup.ts",
-    "src/lib/testing/**/*"
-  ]
-}

package/tsconfig.lib.prod.json

@@ -1,7 +0,0 @@
-{
-  "extends": "./tsconfig.lib.json",
-  "compilerOptions": {
-    "declarationMap": false
-  },
-  "angularCompilerOptions": {}
-}

package/tsconfig.spec.json

@@ -1,31 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "types": [
-      "vitest/globals",
-      "vitest/importMeta",
-      "vite/client",
-      "node",
-      "vitest"
-    ]
-  },
-  "include": [
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx",
-    "src/**/*.d.ts"
-  ],
-  "files": [
-    "src/test-setup.ts"
-  ]
-}

package/vite.config.mts

@@ -1,10 +0,0 @@
-/// <reference types='vitest' />
-import { defineConfig } from 'vitest/config';
-import { createBaseViteConfig } from '../../vite.config.base';
-
-export default defineConfig(() =>
-	createBaseViteConfig({
-		dirname: __dirname,
-		name: 'logging',
-	}),
-);