@leanstacks/lambda-utils 0.1.0-alpha.4 → 0.1.0

package/dist/index.esm.js

@@ -0,0 +1,2 @@
+import e from"pino";import{lambdaRequestTracker as n,StructuredLogFormatter as t,CloudwatchLogFormatter as o,pinoLambdaDestination as i}from"pino-lambda";const l=n();class r{constructor(n){this._loggerConfig={enabled:!0,level:"info",format:"json"},this._instance=null,this._createLogger=()=>{const n="json"===this._loggerConfig.format?new t:new o,l=i({formatter:n});return e({enabled:this._loggerConfig.enabled,level:this._loggerConfig.level},l)},n&&(this._loggerConfig={enabled:n.enabled??!0,level:n.level??"info",format:n.format??"json"})}get instance(){return null===this._instance&&(this._instance=this._createLogger()),this._instance}}export{r as Logger,l as withRequestTracking};
+//# sourceMappingURL=index.esm.js.map

package/dist/index.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.esm.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,2 @@
+"use strict";var e=require("pino"),t=require("pino-lambda");const n=t.lambdaRequestTracker();exports.Logger=class{constructor(n){this._loggerConfig={enabled:!0,level:"info",format:"json"},this._instance=null,this._createLogger=()=>{const n="json"===this._loggerConfig.format?new t.StructuredLogFormatter:new t.CloudwatchLogFormatter,r=t.pinoLambdaDestination({formatter:n});return e({enabled:this._loggerConfig.enabled,level:this._loggerConfig.level},r)},n&&(this._loggerConfig={enabled:n.enabled??!0,level:n.level??"info",format:n.format??"json"})}get instance(){return null===this._instance&&(this._instance=this._createLogger()),this._instance}},exports.withRequestTracking=n;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/logging/logger.d.ts

@@ -0,0 +1,59 @@
+import pino from 'pino';
+/**
+ * Logger middleware which adds AWS Lambda attributes to log messages.
+ *
+ * @example
+ * ```typescript
+ * import { withRequestTracking } from '@leanstacks/lambda-utils';
+ *
+ * export const handler = async (event, context) => {
+ *   withRequestTracking(event, context);
+ *
+ *   // Your Lambda handler logic here
+ * };
+ * ```
+ */
+export declare const withRequestTracking: (event: import("pino-lambda").LambdaEvent, context: import("pino-lambda").LambdaContext) => void;
+/**
+ * Configuration options for the Logger
+ */
+export interface LoggerConfig {
+    /** Whether logging is enabled */
+    enabled?: boolean;
+    /** Minimum log level (e.g., 'debug', 'info', 'warn', 'error') */
+    level?: 'debug' | 'info' | 'warn' | 'error';
+    /** Output format: 'json' for StructuredLogFormatter, 'text' for CloudwatchLogFormatter */
+    format?: 'json' | 'text';
+}
+/**
+ * Logger class which provides a Pino logger instance with AWS Lambda attributes.
+ *
+ * @example
+ * ```typescript
+ * import { Logger } from '@leanstacks/lambda-utils';
+ * const logger = new Logger().instance;
+ *
+ * logger.info('Hello, world!');
+ * ```
+ */
+export declare class Logger {
+    private _loggerConfig;
+    private _instance;
+    constructor(config?: LoggerConfig);
+    /**
+     * Creates a new, fully configured Pino logger instance.
+     */
+    private _createLogger;
+    /**
+     * Get the logger instance.
+     *
+     * @example
+     * ```typescript
+     * import { Logger } from '@leanstacks/lambda-utils';
+     * const logger = new Logger().instance;
+     *
+     * logger.info('Hello, world!');
+     * ```
+     */
+    get instance(): pino.Logger;
+}

package/package.json

@@ -1,9 +1,31 @@
 {
   "name": "@leanstacks/lambda-utils",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0",
   "description": "A collection of utilities and helper functions designed to streamline the development of AWS Lambda functions using TypeScript.",
   "main": "dist/index.js",
+  "module": "dist/index.esm.js",
   "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "docs"
+  ],
+  "keywords": [
+    "lambda",
+    "aws",
+    "utilities",
+    "nodejs",
+    "typescript"
+  ],
+  "author": "Matthew Warman <leanstacker@gmail.com> (https://leanstacks.com)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/leanstacks/lambda-utils.git"
+  },
+  "homepage": "https://github.com/leanstacks/lambda-utils#readme",
+  "bugs": {
+    "url": "https://github.com/leanstacks/lambda-utils/issues"
+  },
   "scripts": {
     "build": "rollup -c",
     "build:watch": "rollup -c -w",
@@ -12,31 +34,28 @@
     "format:check": "prettier --check \"src/**/*.ts\"",
     "lint": "eslint src",
     "lint:fix": "eslint src --fix",
+    "prepare": "husky",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage"
   },
-  "keywords": [
-    "lambda",
-    "aws",
-    "utilities",
-    "nodejs",
-    "typescript"
-  ],
-  "author": "Matthew Warman <leanstacker@gmail.com> (https://leanstacks.com)",
-  "license": "MIT",
   "devDependencies": {
     "@eslint/js": "9.39.2",
+    "@rollup/plugin-commonjs": "29.0.0",
+    "@rollup/plugin-node-resolve": "16.0.3",
+    "@rollup/plugin-terser": "0.4.4",
     "@types/aws-lambda": "8.10.159",
     "@types/jest": "30.0.0",
     "@types/node": "25.0.3",
     "@typescript-eslint/eslint-plugin": "8.50.0",
     "@typescript-eslint/parser": "8.50.0",
     "eslint": "9.39.2",
+    "husky": "9.1.7",
     "jest": "30.2.0",
     "prettier": "3.7.4",
     "rimraf": "6.1.2",
     "rollup": "4.53.5",
+    "rollup-plugin-peer-deps-external": "2.2.4",
     "rollup-plugin-typescript2": "0.36.0",
     "ts-jest": "29.4.6",
     "ts-node": "10.9.2",

package/.editorconfig

@@ -1,12 +0,0 @@
-# This file is used to define coding styles and formatting rules for the project.
-# For more information, see https://editorconfig.org/
-root=true
-
-[*]
-charset=utf-8
-end_of_line=lf
-indent_style=space
-indent_size=2
-insert_final_newline=true
-max_line_length=120
-trim_trailing_whitespace=true

package/.github/ISSUE_TEMPLATE/bug.md

@@ -1,47 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: bug
-assignees: ''
----
-
-## Describe the bug
-
-_Provide a clear and concise description of what the bug is._
-
-## Steps to reproduce
-
-Steps to reproduce the behavior:
-
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-## Expected behavior
-
-_Provide a clear and concise description of what you expected to happen._
-
-## Screenshots
-
-_If applicable, add screenshots to help explain your problem._
-
-## Environment
-
-**Desktop (please complete the following information):**
-
-- OS: [e.g. iOS]
-- Browser [e.g. chrome, safari]
-- Version [e.g. 22]
-
-**Smartphone (please complete the following information):**
-
-- Device: [e.g. iPhone6]
-- OS: [e.g. iOS8.1]
-- Browser [e.g. stock browser, safari]
-- Version [e.g. 22]
-
-## Additional context
-
-_Add any other context about the problem here._

package/.github/ISSUE_TEMPLATE/story.md

@@ -1,25 +0,0 @@
----
-name: Story
-about: New feature or improvement request
-title: ''
-labels: enhancement
-assignees: ''
----
-
-## Describe the story
-
-_Provide a clear description of the new feature or improvement to existing functionality._
-
-## Acceptance criteria
-
-_Provide clear acceptance criteria to validate the story is complete._
-
-[Gherkin syntax](https://cucumber.io/docs/gherkin/reference) example:
-
-> Given the 'PERSONA' has 'DONE SOMETHING'  
-> When the 'PERSONA' does 'ONE THING'  
-> Then the 'PERSONA' must do 'ANOTHER THING'
-
-## Additional context
-
-_Add any other context about the story here._

package/.github/ISSUE_TEMPLATE/task.md

@@ -1,15 +0,0 @@
----
-name: Task
-about: A chore unrelated to features or problems
-title: ''
-labels: task
-assignees: ''
----
-
-## Describe the task
-
-_Provide a clear description of the task._
-
-## Additional context
-
-_Add any other context about the task here._

package/.github/PULL_REQUEST_TEMPLATE.md

@@ -1,39 +0,0 @@
-:loudspeaker: **Instructions**
-
-- Begin with a **DRAFT** pull request.
-- Follow _italicized instructions_ to add detail to assist the reviewers.
-- After completing all checklist items, change the pull request to **READY**.
-
----
-
-### :wrench: Change Summary
-
-_Describe the changes included in this pull request. Link to the associated [GitHub](https://docs.github.com/en/issues/tracking-your-work-with-issues/using-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword) or Jira issue(s)._
-
-- see #1234
-- Added the [...]
-- Updated the [...]
-- Fixed the [...]
-
-### :memo: Checklist
-
-_Pull request authors must complete the following tasks before marking the PR as ready to review._
-
-- [ ] Complete a self-review of changes
-- [ ] Unit tests have been created or updated
-- [ ] The code is free of [new] lint errors and warnings
-- [ ] Update project documentation as needed: README, /docs, JSDoc, etc.
-
-### :test_tube: Steps to Test
-
-_Describe the process to test the changes in this pull request._
-
-1. Go to [...]
-2. Click on [...]
-3. Verify that [...]
-
-### :link: Additional Information
-
-_Optionally, provide additional details, screenshots, or URLs that may assist the reviewer._
-
-- [...]

package/.github/copilot-instructions.md

@@ -1,101 +0,0 @@
-# Lambda Utilities Project Instructions
-
-This project contains a set of utilities and helper functions designed to streamline the development of AWS Lambda functions using TypeScript. The utilities cover common tasks such as input validation, response formatting, error handling, and logging. The project is packaged and published as an npm package for easy integration into other Lambda projects.
-
----
-
-## Technology Stack
-
-Each pattern project uses the following technology stack:
-
-- **Language:** TypeScript
-- **Platform:** AWS Lambda
-- **Runtime:** Node.js 24.x
-- **AWS SDK:** v3 (modular packages)
-- **Testing:** Jest
-- **Linting/Formatting:** ESLint + Prettier
-- **Validation:** Zod
-- **Logging:** Pino + Pino-Lambda
-- **Package Manager:** npm
-- **Package Bundler:** rollup
-
----
-
-## Pattern Project Structure
-
-Each pattern project follows a consistent directory and file structure to promote maintainability and scalability. Below is an example structure:
-
-```
-/docs                               # Project documentation
-  README.md                         # Documentation table of contents
-
-/src
-  /logging
-    logger.ts                       # Logger utility using Pino
-    logger.test.ts                  # Unit tests for logger
-  /clients
-    dynamodb-client.ts              # AWS SDK client for DynamoDB
-    dynamodb-client.test.ts         # Unit tests for DynamoDB client
-    lambda-client.ts                # AWS SDK client for Lambda
-    lambda-client.test.ts           # Unit tests for Lambda client
-  /validation
-    config.ts                       # Configuration validation with Zod
-    config.test.ts                  # Unit tests for config
-    validator.ts                    # Generic validator helpers
-    validator.test.ts               # Unit tests for validator
-  /responses
-    apigateway-response.ts          # Standard API response helpers
-    apigateway-response.test.ts     # Unit tests for API response helpers
-.editorconfig                       # Editor config
-.gitignore                          # Git ignore rules
-.nvmrc                              # Node version manager config
-.prettierrc                         # Prettier config
-eslint.config.mjs                   # ESLint config
-jest.config.ts                      # App Jest config
-jest.setup.ts                       # App Jest setup
-package.json                        # App NPM package config
-README.md                           # Project README
-tsconfig.json                       # Project TypeScript config
-```
-
----
-
-## Source Code Guidelines
-
-Each pattern project follows best practices for source code organization, naming conventions, and coding standards. Below are the key guidelines:
-
-- Use **TypeScript** for all source and infrastructure code.
-- Use arrow functions for defining functions.
-- Use path aliases for cleaner imports (e.g., `@utils`, `@models`).
-- Organize import statements: external packages first, then internal modules.
-- Use async/await for asynchronous operations.
-- Document functions and modules with JSDoc comments.
-
-### Source Code Commands & Scripts
-
-- Use `npm run build` to compile TypeScript.
-- Use `npm run test` to run tests.
-- Use `npm run test:coverage` to run tests with coverage report.
-- Use `npm run lint` to run ESLint.
-- Use `npm run lint:fix` to fix ESLint issues.
-- Use `npm run format` to run Prettier to format code.
-- Use `npm run format:check` to check code formatting with Prettier.
-
----
-
-## Unit Testing Guidelines
-
-Each pattern project includes comprehensive unit tests for both application and infrastructure code. Below are the key guidelines for writing unit tests:
-
-- Use the **Jest** testing framework.
-- Place test files next to the source file, with `.test.ts` suffix.
-- Use `describe` and `it` blocks for organization.
-- Use `beforeEach` for setup and `afterEach` for cleanup.
-- Use `expect` assertions for results.
-- Mock dependencies to isolate the component under test.
-- Mock external calls (e.g., AWS SDK, databases).
-- Structure your tests using the Arrange-Act-Assert pattern:
-  - **Arrange:** Set up the test environment, including any necessary mocks and test data.
-  - **Act:** Execute the function or service being tested.
-  - **Assert:** Verify that the results are as expected.
-  - Add comments to separate these sections for clarity.

package/.nvmrc

@@ -1 +0,0 @@
-24.11.1

package/.prettierrc

@@ -1,8 +0,0 @@
-{
-  "plugins": [],
-  "printWidth": 120,
-  "semi": true,
-  "singleQuote": true,
-  "tabWidth": 2,
-  "trailingComma": "all"
-}

package/eslint.config.mjs

@@ -1,44 +0,0 @@
-import js from '@eslint/js';
-import tsPlugin from '@typescript-eslint/eslint-plugin';
-import tsParser from '@typescript-eslint/parser';
-
-export default [
-  {
-    ignores: ['dist', 'node_modules'],
-  },
-  {
-    files: ['src/**/*.ts'],
-    languageOptions: {
-      parser: tsParser,
-      parserOptions: {
-        ecmaVersion: 2020,
-        sourceType: 'module',
-      },
-      globals: {
-        console: 'readonly',
-        process: 'readonly',
-        describe: 'readonly',
-        it: 'readonly',
-        expect: 'readonly',
-        beforeEach: 'readonly',
-        afterEach: 'readonly',
-        jest: 'readonly',
-      },
-    },
-    plugins: {
-      '@typescript-eslint': tsPlugin,
-    },
-    rules: {
-      ...js.configs.recommended.rules,
-      ...tsPlugin.configs.recommended.rules,
-      '@typescript-eslint/no-unused-vars': [
-        'error',
-        {
-          argsIgnorePattern: '^_',
-          varsIgnorePattern: '^_',
-        },
-      ],
-      '@typescript-eslint/no-explicit-any': 'warn',
-    },
-  },
-];

package/jest.config.ts

@@ -1,15 +0,0 @@
-import type { Config } from 'jest';
-
-const config: Config = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  testMatch: ['<rootDir>/src/**/*.test.ts'],
-  moduleNameMapper: {
-    '^@/(.*)$': '<rootDir>/$1',
-  },
-  coverageDirectory: 'coverage',
-  collectCoverageFrom: ['src/**/*.ts', '!src/**/*.test.ts', '!src/**/index.ts'],
-  coverageReporters: ['json', 'json-summary', 'lcov', 'text', 'clover'],
-};
-
-export default config;

package/jest.setup.ts

@@ -1,9 +0,0 @@
-// Jest setup file for global test configuration
-// Add any global test setup here
-
-// Mock pino-lambda for tests
-jest.mock('pino-lambda', () => {
-  return {
-    target: 'pino-lambda',
-  };
-});

package/rollup.config.js

@@ -1,18 +0,0 @@
-import typescript from 'rollup-plugin-typescript2';
-
-export default {
-  input: 'src/index.ts',
-  output: [
-    {
-      file: 'dist/index.js',
-      format: 'esm',
-    },
-  ],
-  external: ['pino', 'pino-lambda', 'zod', '@aws-sdk/client-dynamodb', '@aws-sdk/client-lambda'],
-  plugins: [
-    typescript({
-      tsconfig: 'tsconfig.json',
-      clean: true,
-    }),
-  ],
-};

package/src/logging/logger.test.ts

@@ -1,400 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import pino from 'pino';
-import { CloudwatchLogFormatter, pinoLambdaDestination, StructuredLogFormatter } from 'pino-lambda';
-import { Logger, withRequestTracking } from './logger';
-
-// Mock pino-lambda module
-jest.mock('pino-lambda');
-
-// Mock pino module
-jest.mock('pino');
-
-describe('Logger', () => {
-  // Setup and cleanup
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('withRequestTracking', () => {
-    it('should be exported from logger module', () => {
-      // Arrange
-      // withRequestTracking is exported from logger.ts and is the result of calling lambdaRequestTracker()
-      // from pino-lambda. Jest mocks mean it will be the mocked value.
-
-      // Act & Assert
-      // We just verify that it was exported (defined by the import statement at the top)
-      // The actual functionality of lambdaRequestTracker is tested in pino-lambda
-      expect(typeof withRequestTracking === 'function' || withRequestTracking === undefined).toBe(true);
-    });
-  });
-
-  describe('constructor', () => {
-    it('should create Logger with default configuration', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const logger = new Logger();
-
-      // Assert
-      expect(logger).toBeDefined();
-    });
-
-    it('should create Logger with custom enabled configuration', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const logger = new Logger({ enabled: false });
-      const _instance = logger.instance;
-
-      // Assert
-      expect(pino).toHaveBeenCalledWith(
-        expect.objectContaining({
-          enabled: false,
-        }),
-        expect.anything(),
-      );
-    });
-
-    it('should create Logger with custom log level configuration', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const logger = new Logger({ level: 'debug' });
-      const _instance = logger.instance;
-
-      // Assert
-      expect(pino).toHaveBeenCalledWith(
-        expect.objectContaining({
-          level: 'debug',
-        }),
-        expect.anything(),
-      );
-    });
-
-    it('should create Logger with custom format configuration (json)', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const logger = new Logger({ format: 'json' });
-      const _instance = logger.instance;
-
-      // Assert
-      expect(StructuredLogFormatter).toHaveBeenCalled();
-    });
-
-    it('should create Logger with custom format configuration (text)', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const logger = new Logger({ format: 'text' });
-      const _instance = logger.instance;
-
-      // Assert
-      expect(CloudwatchLogFormatter).toHaveBeenCalled();
-    });
-
-    it('should merge provided config with defaults', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const logger = new Logger({ level: 'error' });
-      const _instance = logger.instance;
-
-      // Assert
-      expect(pino).toHaveBeenCalledWith(
-        expect.objectContaining({
-          enabled: true,
-          level: 'error',
-        }),
-        expect.anything(),
-      );
-    });
-  });
-
-  describe('instance getter', () => {
-    it('should return a Pino logger instance', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn(), warn: jest.fn(), error: jest.fn(), debug: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-      const logger = new Logger();
-
-      // Act
-      const instance = logger.instance;
-
-      // Assert
-      expect(instance).toBe(mockLogger);
-      expect(instance).toHaveProperty('info');
-      expect(instance).toHaveProperty('warn');
-      expect(instance).toHaveProperty('error');
-      expect(instance).toHaveProperty('debug');
-    });
-
-    it('should create logger instance only once (lazy initialization)', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-      const logger = new Logger();
-
-      // Act
-      const instance1 = logger.instance;
-      const instance2 = logger.instance;
-
-      // Assert
-      expect(instance1).toBe(instance2);
-      expect(pino).toHaveBeenCalledTimes(1);
-    });
-
-    it('should configure pino with enabled flag', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const logger = new Logger({ enabled: false });
-      const _instance = logger.instance;
-
-      // Assert
-      expect(pino).toHaveBeenCalledWith(
-        expect.objectContaining({
-          enabled: false,
-        }),
-        expect.anything(),
-      );
-    });
-
-    it('should configure pino with log level', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const logger = new Logger({ level: 'warn' });
-      const _instance = logger.instance;
-
-      // Assert
-      expect(pino).toHaveBeenCalledWith(
-        expect.objectContaining({
-          level: 'warn',
-        }),
-        expect.anything(),
-      );
-    });
-
-    it('should call pinoLambdaDestination with selected formatter', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const logger = new Logger({ format: 'json' });
-      const _instance = logger.instance;
-
-      // Assert
-      expect(pinoLambdaDestination).toHaveBeenCalledWith(
-        expect.objectContaining({
-          formatter: expect.any(StructuredLogFormatter),
-        }),
-      );
-    });
-
-    it('should use StructuredLogFormatter when format is json', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const logger = new Logger({ format: 'json' });
-      const _instance = logger.instance;
-
-      // Assert
-      expect(StructuredLogFormatter).toHaveBeenCalled();
-    });
-
-    it('should use CloudwatchLogFormatter when format is text', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const logger = new Logger({ format: 'text' });
-      const _instance = logger.instance;
-
-      // Assert
-      expect(CloudwatchLogFormatter).toHaveBeenCalled();
-    });
-  });
-
-  describe('Logger configurations', () => {
-    it('should support all log levels', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-      const levels: Array<'debug' | 'info' | 'warn' | 'error'> = ['debug', 'info', 'warn', 'error'];
-
-      // Act & Assert
-      levels.forEach((level) => {
-        jest.clearAllMocks();
-        jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-        (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-        const logger = new Logger({ level });
-        const _instance = logger.instance;
-
-        expect(pino).toHaveBeenCalledWith(
-          expect.objectContaining({
-            level,
-          }),
-          expect.anything(),
-        );
-      });
-    });
-
-    it('should support both json and text formats', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const jsonLogger = new Logger({ format: 'json' });
-      const _jsonInstance = jsonLogger.instance;
-      const structuredFormatterCallCount = (StructuredLogFormatter as jest.Mock).mock.calls.length;
-
-      jest.clearAllMocks();
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      const textLogger = new Logger({ format: 'text' });
-      const _textInstance = textLogger.instance;
-
-      // Assert
-      expect(structuredFormatterCallCount).toBeGreaterThan(0);
-      expect(CloudwatchLogFormatter).toHaveBeenCalled();
-    });
-
-    it('should support enabled and disabled logging', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const enabledLogger = new Logger({ enabled: true });
-      const _enabledInstance = enabledLogger.instance;
-      const firstCallArgs = jest.mocked(pino).mock.calls[0];
-
-      jest.clearAllMocks();
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      const disabledLogger = new Logger({ enabled: false });
-      const _disabledInstance = disabledLogger.instance;
-      const secondCallArgs = jest.mocked(pino).mock.calls[0];
-
-      // Assert
-      expect(firstCallArgs[0]).toEqual(expect.objectContaining({ enabled: true }));
-      expect(secondCallArgs[0]).toEqual(expect.objectContaining({ enabled: false }));
-    });
-  });
-
-  describe('integration scenarios', () => {
-    it('should create multiple logger instances with different configurations', () => {
-      // Arrange
-      const mockLogger1 = { info: jest.fn(), level: 'debug' };
-      const mockLogger2 = { info: jest.fn(), level: 'error' };
-      jest
-        .mocked(pino)
-        .mockReturnValueOnce(mockLogger1 as unknown as any)
-        .mockReturnValueOnce(mockLogger2 as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const debugLogger = new Logger({ level: 'debug', format: 'json' });
-      const errorLogger = new Logger({ level: 'error', format: 'text' });
-
-      const instance1 = debugLogger.instance;
-      const instance2 = errorLogger.instance;
-
-      // Assert
-      expect(instance1).toBe(mockLogger1);
-      expect(instance2).toBe(mockLogger2);
-      expect(pino).toHaveBeenCalledTimes(2);
-    });
-
-    it('should handle partial configuration overrides', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const logger = new Logger({ level: 'warn' });
-      const _instance = logger.instance;
-
-      // Assert - should have custom level but default enabled and format
-      expect(pino).toHaveBeenCalledWith(
-        expect.objectContaining({
-          enabled: true,
-          level: 'warn',
-        }),
-        expect.anything(),
-      );
-      expect(StructuredLogFormatter).toHaveBeenCalled();
-    });
-
-    it('should handle full configuration override', () => {
-      // Arrange
-      const mockLogger = { info: jest.fn() };
-      jest.mocked(pino).mockReturnValue(mockLogger as unknown as any);
-      (pinoLambdaDestination as jest.Mock).mockReturnValue({});
-
-      // Act
-      const logger = new Logger({
-        enabled: false,
-        level: 'error',
-        format: 'text',
-      });
-      const _instance = logger.instance;
-
-      // Assert
-      expect(pino).toHaveBeenCalledWith(
-        expect.objectContaining({
-          enabled: false,
-          level: 'error',
-        }),
-        expect.anything(),
-      );
-      expect(CloudwatchLogFormatter).toHaveBeenCalled();
-    });
-  });
-});

package/src/logging/logger.ts

@@ -1,104 +0,0 @@
-import pino from 'pino';
-import {
-  CloudwatchLogFormatter,
-  lambdaRequestTracker,
-  pinoLambdaDestination,
-  StructuredLogFormatter,
-} from 'pino-lambda';
-
-/**
- * Logger middleware which adds AWS Lambda attributes to log messages.
- *
- * @example
- * ```typescript
- * import { withRequestTracking } from '@leanstacks/lambda-utils';
- *
- * export const handler = async (event, context) => {
- *   withRequestTracking(event, context);
- *
- *   // Your Lambda handler logic here
- * };
- * ```
- */
-export const withRequestTracking = lambdaRequestTracker();
-
-/**
- * Configuration options for the Logger
- */
-export interface LoggerConfig {
-  /** Whether logging is enabled */
-  enabled?: boolean;
-  /** Minimum log level (e.g., 'debug', 'info', 'warn', 'error') */
-  level?: 'debug' | 'info' | 'warn' | 'error';
-  /** Output format: 'json' for StructuredLogFormatter, 'text' for CloudwatchLogFormatter */
-  format?: 'json' | 'text';
-}
-
-/**
- * Logger class which provides a Pino logger instance with AWS Lambda attributes.
- *
- * @example
- * ```typescript
- * import { Logger } from '@leanstacks/lambda-utils';
- * const logger = new Logger().instance;
- *
- * logger.info('Hello, world!');
- * ```
- */
-export class Logger {
-  private _loggerConfig: LoggerConfig = {
-    enabled: true,
-    level: 'info',
-    format: 'json',
-  };
-
-  private _instance: pino.Logger | null = null;
-
-  constructor(config?: LoggerConfig) {
-    if (config) {
-      this._loggerConfig = {
-        enabled: config.enabled ?? true,
-        level: config.level ?? 'info',
-        format: config.format ?? 'json',
-      };
-    }
-  }
-
-  /**
-   * Creates a new, fully configured Pino logger instance.
-   */
-  private _createLogger = (): pino.Logger => {
-    const formatter =
-      this._loggerConfig.format === 'json' ? new StructuredLogFormatter() : new CloudwatchLogFormatter();
-
-    const lambdaDestination = pinoLambdaDestination({
-      formatter,
-    });
-
-    return pino(
-      {
-        enabled: this._loggerConfig.enabled,
-        level: this._loggerConfig.level,
-      },
-      lambdaDestination,
-    );
-  };
-
-  /**
-   * Get the logger instance.
-   *
-   * @example
-   * ```typescript
-   * import { Logger } from '@leanstacks/lambda-utils';
-   * const logger = new Logger().instance;
-   *
-   * logger.info('Hello, world!');
-   * ```
-   */
-  get instance(): pino.Logger {
-    if (this._instance === null) {
-      this._instance = this._createLogger();
-    }
-    return this._instance;
-  }
-}

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "lib": ["ES2020"],
-    "declaration": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "moduleResolution": "node",
-    "baseUrl": "./src",
-    "paths": {
-      "@/*": ["./*"]
-    }
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}