@dismissible/nestjs-logger 0.0.2-canary.738340d.0

package/README.md

@@ -0,0 +1,138 @@
+# @dismissible/nestjs-logger
+
+A flexible logging module for NestJS applications in the Dismissible ecosystem.
+
+> **Part of the Dismissible API** - This library is part of the [Dismissible API](https://dismissible.io) ecosystem. Visit [dismissible.io](https://dismissible.io) for more information and documentation.
+
+## Overview
+
+This library provides a standardized logging interface (`IDismissibleLogger`) and a default console logger implementation. It's designed to be easily replaceable with custom logging implementations (e.g., Winston, Pino, etc.) while maintaining a consistent API across the Dismissible ecosystem.
+
+## Installation
+
+```bash
+npm install @dismissible/nestjs-logger
+```
+
+## Getting Started
+
+### Basic Usage
+
+The simplest way to use the logger is with the default console logger:
+
+```typescript
+import { Module } from '@nestjs/common';
+import { LoggerModule } from '@dismissible/nestjs-logger';
+
+@Module({
+  imports: [
+    LoggerModule.forRoot({
+      // Uses default ConsoleLogger if not specified
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### Using the Logger in Your Services
+
+```typescript
+import { Injectable, Inject } from '@nestjs/common';
+import { DISMISSIBLE_LOGGER, IDismissibleLogger } from '@dismissible/nestjs-logger';
+
+@Injectable()
+export class MyService {
+  constructor(@Inject(DISMISSIBLE_LOGGER) private readonly logger: IDismissibleLogger) {}
+
+  doSomething() {
+    this.logger.debug('Debug message', { context: 'MyService' });
+    this.logger.info('Info message', { userId: 'user-123' });
+    this.logger.warn('Warning message', { itemId: 'item-456' });
+    this.logger.error('Error message', new Error('Something went wrong'), {
+      additionalContext: 'value',
+    });
+  }
+}
+```
+
+### Custom Logger Implementation
+
+You can provide your own logger implementation:
+
+```typescript
+import { Module } from '@nestjs/common';
+import { LoggerModule, IDismissibleLogger } from '@dismissible/nestjs-logger';
+import * as winston from 'winston';
+
+class WinstonLogger implements IDismissibleLogger {
+  private logger = winston.createLogger({
+    // Your Winston configuration
+  });
+
+  debug(message: string, context?: object): void {
+    this.logger.debug(message, context);
+  }
+
+  info(message: string, context?: object): void {
+    this.logger.info(message, context);
+  }
+
+  warn(message: string, context?: object): void {
+    this.logger.warn(message, context);
+  }
+
+  error(message: string, error?: Error, context?: object): void {
+    this.logger.error(message, { error, ...context });
+  }
+}
+
+@Module({
+  imports: [
+    LoggerModule.forRoot({
+      logger: WinstonLogger,
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+## API Reference
+
+### IDismissibleLogger Interface
+
+```typescript
+interface IDismissibleLogger {
+  debug(message: string, context?: object): void;
+  info(message: string, context?: object): void;
+  warn(message: string, context?: object): void;
+  error(message: string, error?: Error, context?: object): void;
+}
+```
+
+### LoggerModule
+
+#### `LoggerModule.forRoot(options)`
+
+Configures the logger module with the provided options.
+
+**Options:**
+
+- `logger?: Type<IDismissibleLogger>` - Custom logger class (defaults to `Logger`)
+
+**Returns:** `DynamicModule`
+
+## Global Module
+
+The `LoggerModule` is registered as a global module, so you only need to import it once in your root module. The logger will be available throughout your application via dependency injection.
+
+## Related Packages
+
+This logger is used by other Dismissible packages:
+
+- `@dismissible/nestjs-dismissible` - Main dismissible service
+- `@dismissible/nestjs-storage` - Storage adapters
+- `@dismissible/nestjs-postgres-storage` - PostgreSQL storage adapter
+
+## License
+
+MIT

package/jest.config.ts

@@ -0,0 +1,10 @@
+export default {
+  displayName: 'logger',
+  preset: '../../jest.preset.js',
+  testEnvironment: 'node',
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  coverageDirectory: '../../coverage/libs/logger',
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@dismissible/nestjs-logger",
+  "version": "0.0.2-canary.738340d.0",
+  "description": "Console logger module for Dismissible applications",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./src/index.mjs",
+      "require": "./src/index.js",
+      "types": "./src/index.d.ts"
+    }
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/core": "^11.0.0",
+    "class-validator": "^0.14.0",
+    "class-transformer": "^0.5.0"
+  },
+  "peerDependenciesMeta": {
+    "@nestjs/common": {
+      "optional": false
+    },
+    "@nestjs/core": {
+      "optional": false
+    },
+    "class-validator": {
+      "optional": false
+    },
+    "class-transformer": {
+      "optional": false
+    }
+  },
+  "keywords": [
+    "nestjs",
+    "logger",
+    "logging"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": ""
+  }
+}

package/project.json

@@ -0,0 +1,42 @@
+{
+  "name": "logger",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "libs/logger/src",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/libs/logger",
+        "main": "libs/logger/src/index.ts",
+        "tsConfig": "libs/logger/tsconfig.lib.json",
+        "assets": ["libs/logger/package.json", "libs/logger/README.md"],
+        "generatePackageJson": true
+      }
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint",
+      "outputs": ["{options.outputFile}"],
+      "options": {
+        "lintFilePatterns": ["libs/logger/**/*.ts"]
+      }
+    },
+    "test": {
+      "executor": "@nx/jest:jest",
+      "outputs": ["{workspaceRoot}/coverage/libs/logger"],
+      "options": {
+        "jestConfig": "libs/logger/jest.config.ts",
+        "passWithNoTests": true
+      }
+    },
+    "npm-publish": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "npm publish --access public",
+        "cwd": "dist/libs/logger"
+      }
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './logger';
+export * from './logger.interface';
+export * from './logger.module';

package/src/logger.interface.ts

@@ -0,0 +1,29 @@
+/**
+ * Injection token for the logger provider.
+ */
+export const DISMISSIBLE_LOGGER = Symbol('DISMISSIBLE_LOGGER');
+
+/**
+ * Interface for logger providers.
+ */
+export interface IDismissibleLogger {
+  /**
+   * Log a debug message.
+   */
+  debug(message: string, context?: object): void;
+
+  /**
+   * Log an info message.
+   */
+  info(message: string, context?: object): void;
+
+  /**
+   * Log a warning message.
+   */
+  warn(message: string, context?: object): void;
+
+  /**
+   * Log an error message.
+   */
+  error(message: string, error?: Error, context?: object): void;
+}

package/src/logger.module.ts

@@ -0,0 +1,25 @@
+import { DynamicModule, Module, Type } from '@nestjs/common';
+import { DISMISSIBLE_LOGGER, IDismissibleLogger } from './logger.interface';
+import { Logger } from './logger';
+
+export type IDismissibleLoggerModuleOptions = {
+  /** Custom logger provider implementation */
+  logger?: Type<IDismissibleLogger>;
+};
+
+@Module({})
+export class LoggerModule {
+  static forRoot(options: IDismissibleLoggerModuleOptions): DynamicModule {
+    return {
+      module: LoggerModule,
+      providers: [
+        {
+          provide: DISMISSIBLE_LOGGER,
+          useClass: options.logger ?? Logger,
+        },
+      ],
+      exports: [DISMISSIBLE_LOGGER],
+      global: true,
+    };
+  }
+}

package/src/logger.ts

@@ -0,0 +1,8 @@
+import { ConsoleLogger } from '@nestjs/common';
+import { IDismissibleLogger } from './logger.interface';
+
+export class Logger extends ConsoleLogger implements IDismissibleLogger {
+  info(message: string, context?: any[]): void {
+    super.log(message, context);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ],
+  "compilerOptions": {
+    "esModuleInterop": true
+  }
+}

package/tsconfig.lib.json

@@ -0,0 +1,14 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "module": "commonjs",
+    "types": ["node"],
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "target": "ES2021"
+  },
+  "exclude": ["node_modules", "**/*.spec.ts", "**/*.test.ts"],
+  "include": ["src/**/*.ts"]
+}