hierarchical-area-logger 0.2.0

package/.prettierignore

@@ -0,0 +1,4 @@
+node_modules
+dist
+coverage
+*.log

package/.prettierrc

@@ -0,0 +1,8 @@
+{
+  "semi": true,
+  "trailingComma": "es5",
+  "singleQuote": true,
+  "printWidth": 80,
+  "tabWidth": 2,
+  "useTabs": false
+}

package/CONTRIBUTING.md

@@ -0,0 +1,313 @@
+# 🤝 Contributing to Hierarchical Area Logger
+
+Thank you for your interest in contributing to this TypeScript logging library! This guide will help you get started and ensure your contributions align with the project standards.
+
+## 📋 Table of Contents
+
+- [Development Setup](#development-setup)
+- [Development Workflow](#development-workflow)
+- [Project Structure](#project-structure)
+- [Code Standards](#code-standards)
+- [Testing](#testing)
+- [Pull Request Process](#pull-request-process)
+- [Release Process](#release-process)
+
+## 🛠 Development Setup
+
+### Prerequisites
+
+- **Node.js** (v18 or higher)
+- **npm** or **yarn** package manager
+- **TypeScript** knowledge
+
+### Installation
+
+1. **Fork and clone the repository**
+
+   ```bash
+   git clone https://github.com/Em3ODMe/hierarchical-area-logger.git
+   cd hierarchical-area-logger
+   ```
+
+2. **Install dependencies**
+
+   ```bash
+   npm install
+   ```
+
+3. **Verify setup**
+   ```bash
+   npm run lint:check
+   npm test
+   npm run build
+   ```
+
+## 🔄 Development Workflow
+
+### Available Scripts
+
+| Script             | Purpose                  | When to Use        |
+| ------------------ | ------------------------ | ------------------ |
+| `npm run dev`      | Watch mode development   | Active development |
+| `npm run build`    | Build the library        | Before committing  |
+| `npm test`         | Run unit tests           | After code changes |
+| `npm run test:ui`  | Interactive test runner  | Debugging tests    |
+| `npm run lint`     | Check code quality       | Before committing  |
+| `npm run lint:fix` | Auto-fix lint issues     | During development |
+| `npm run coverage` | Generate coverage report | Before PR          |
+
+### Daily Development
+
+1. **Start development server**
+
+   ```bash
+   npm run dev
+   ```
+
+2. **Make changes to source files** in `src/` directory
+
+3. **Run tests frequently**
+
+   ```bash
+   npm test
+   ```
+
+4. **Check linting**
+
+   ```bash
+   npm run lint:check
+   ```
+
+5. **Build before commit**
+   ```bash
+   npm run build
+   ```
+
+## 📁 Project Structure
+
+```
+logger/
+├── src/
+│   ├── index.ts          # Main entry point and exports
+│   ├── Logger.ts         # Core Logger class implementation
+│   ├── types.ts          # TypeScript type definitions
+│   └── utils.ts          # Utility functions
+├── dist/                 # Built output (auto-generated)
+├── test/
+│   └── logger.test.ts    # Test suite
+├── coverage/             # Coverage reports (auto-generated)
+├── package.json          # Project configuration
+├── tsconfig.json         # TypeScript configuration
+├── vitest.config.ts      # Test configuration
+├── eslint.config.js      # Linting configuration
+└── tsup.config.ts        # Build configuration
+```
+
+### Key Files & Responsibilities
+
+- **`src/Logger.ts`**: Core Logger class with area-based logging
+- **`src/types.ts`**: TypeScript interfaces and type definitions
+- **`src/utils.ts`**: Helper functions for log creation and error handling
+- **`src/index.ts`**: Public API exports
+
+## 📝 Code Standards
+
+### TypeScript Configuration
+
+- **Target**: ES2020
+- **Module**: ESNext
+- **Strict mode**: Enabled
+- **Output**: Both CommonJS and ESM modules
+
+### ESLint Rules
+
+Key rules enforced:
+
+- No unused variables (with `_` prefix exception)
+- Warn on `any` types
+- Prefer `const` over `let`
+- No `var` declarations
+- No empty functions (warn)
+
+### Code Style Guidelines
+
+1. **Use TypeScript for all new code**
+2. **Follow existing naming conventions** (camelCase for variables, PascalCase for classes)
+3. **Export only what's necessary** from index.ts
+4. **Add JSDoc comments for public APIs**
+5. **Use meaningful variable and function names**
+
+### Import Organization
+
+```typescript
+// External dependencies
+import { init } from '@paralleldrive/cuid2';
+
+// Internal modules
+import { createRootLogEntry, prettyError } from './utils';
+import { LogData, LoggerOptions, LogEntry } from './types';
+```
+
+## 🧪 Testing
+
+### Test Framework
+
+- **Vitest** for unit testing
+- **Coverage** with v8 provider
+- **100% coverage requirement** for new code
+
+### Writing Tests
+
+1. **Test file location**: `test/` directory
+2. **Naming convention**: `*.test.ts`
+3. **Structure your tests**:
+
+   ```typescript
+   import { describe, it, expect } from 'vitest';
+   import { createLogger } from '../src/index';
+
+   describe('Logger functionality', () => {
+     it('should create logger with event ID', () => {
+       const logger = createLogger({
+         details: { service: 'test' },
+       });
+
+       expect(logger.eventId).toBeDefined();
+       expect(typeof logger.eventId).toBe('string');
+     });
+   });
+   ```
+
+### Test Categories
+
+1. **Unit tests**: Individual function behavior
+2. **Integration tests**: Component interaction
+3. **Edge cases**: Error handling, invalid inputs
+4. **Type safety**: TypeScript compilation checks
+
+## 🔄 Pull Request Process
+
+### Branch Naming
+
+Use descriptive branch names:
+
+- `feature/area-logging-enhancement`
+- `fix/error-handling-bug`
+- `docs/updated-readme`
+
+### Commit Messages
+
+Follow conventional commits:
+
+```
+type(scope): description
+
+feat(logger): add batch logging capability
+fix(types): resolve optional parameter issue
+docs(readme): update installation instructions
+```
+
+### Before Submitting PR
+
+1. **Create feature branch** from main
+2. **Make your changes** with atomic commits
+3. **Ensure all tests pass**:
+   ```bash
+   npm test
+   npm run test
+   ```
+4. **Verify linting**:
+   ```bash
+   npm run lint:check
+   ```
+5. **Build successfully**:
+   ```bash
+   npm run build
+   ```
+6. **Update documentation** if needed
+
+### PR Description Template
+
+```markdown
+## Description
+
+Brief description of changes made.
+
+## Type of Change
+
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Breaking change
+- [ ] Documentation update
+
+## Testing
+
+- [ ] All tests pass
+- [ ] 100% coverage maintained
+- [ ] New tests added for new functionality
+
+## Checklist
+
+- [ ] Code follows project style guidelines
+- [ ] Self-review completed
+- [ ] Documentation updated if necessary
+```
+
+## 🚀 Release Process
+
+### Version Management
+
+- Follow **Semantic Versioning** (SemVer)
+- Update version in `package.json`
+- Create git tag for releases
+
+### Pre-release Checks
+
+1. **All tests pass**
+2. **100% coverage maintained**
+3. **Linting passes**
+4. **Build succeeds**
+5. **Documentation updated**
+
+### Build Verification
+
+```bash
+# Clean build
+rm -rf dist/
+npm run build
+
+# Verify outputs
+ls -la dist/
+# Should contain: index.js, index.mjs, index.d.ts, source maps
+```
+
+### Publishing
+
+1. **Update version** in package.json
+2. **Create git tag**:
+   ```bash
+   git tag v0.1.1
+   git push origin v0.1.1
+   ```
+3. **Publish to npm** (if you have access):
+   ```bash
+   npm publish
+   ```
+
+## 🆘 Getting Help
+
+- **Check existing issues** for similar problems
+- **Read the README.md** for usage examples
+- **Look at test files** for implementation patterns
+- **Review TypeScript types** in `src/types.ts`
+
+## 📚 Additional Resources
+
+- [TypeScript Handbook](https://www.typescriptlang.org/docs/)
+- [Vitest Documentation](https://vitest.dev/)
+- [ESLint Configuration](https://eslint.org/docs/latest/)
+- [Semantic Versioning](https://semver.org/)
+
+---
+
+Thank you for contributing to the Hierarchical Area Logger project! Your contributions help make this library better for everyone. 🎉

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Roman Jankowski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+# 🌲 Hierarchical Area Logger
+
+A lightweight, structured logging utility for TypeScript applications. It allows you to scope logs to specific **Areas**, track request flows via **Event IDs**, and **dump** the entire execution history for debugging or monitoring.
+
+## 🚀 Features
+
+- **Scoped Logging:** Group logs by logical "areas" (e.g., `db-layer`, `auth-service`).
+- **Traceability:** Automatic Event ID generation and Parent Event ID mapping for distributed tracing.
+- **Structured Payloads:** Log rich objects and Error instances without losing metadata.
+- **Snapshot Dumping:** Retrieve the entire log state at any time for analysis or reporting.
+- **Lightweight:** Designed to be dependency-lite and predictable.
+
+---
+
+## 🛠 Installation
+
+```bash
+npm install hierarchical-area-logger
+# or
+yarn add hierarchical-area-logger
+
+```
+
+---
+
+## 💡 Functionality Showcase
+
+### 1. Basic Scoped Logging
+
+Instead of a flat stream of text, the logger categorizes logs into logical areas.
+
+```typescript
+import { createLogger } from 'hierarchical-area-logger';
+
+const logger = createLogger({
+  details: { service: 'payment-gateway' },
+});
+
+const checkout = logger.getArea('checkout-process');
+
+checkout.info('User started checkout');
+checkout.warn('Retry attempt 1 for payment');
+checkout.error('Transaction failed', new Error('Timeout'));
+
+// View the structured output
+console.log(logger.dump());
+```
+
+### 2. Request Traceability
+
+Track a request across your system by linking `eventId` and `parentEventId`.
+
+```typescript
+const logger = createLogger({
+    details: { service: 'payment-gateway' }
+    path: '/api/v1/user',
+    parentEventId: 'incoming-request-id-001'
+});
+
+console.log(logger.eventId); // Automatically generated unique ID
+console.log(logger.parentEventId); // 'incoming-request-id-001'
+
+```
+
+### 3. Log Merging & State Management
+
+You can append existing log data to a logger instance, which is useful for consolidating logs from multiple micro-tasks.
+
+```typescript
+const mainLogger = createLogger({ details: { service: 'orchestrator' } });
+
+const externalLogs = {
+  'worker-1': [
+    { type: 'info', message: 'Task complete', timestamp: Date.now() },
+  ],
+};
+
+mainLogger.appendLogData(externalLogs);
+```
+
+---
+
+## 📖 API Reference
+
+### `createLogger(options)`
+
+Factory function to initialize a new Logger instance.
+
+| Option          | Type      | Description                                |
+| --------------- | --------- | ------------------------------------------ |
+| `details`       | `Details` | Metadata about the service or environment. |
+| `path`          | `string`  | (Optional) The execution path/route.       |
+| `parentEventId` | `string`  | (Optional) ID of the triggering event.     |
+
+### `LoggerInstance` Methods
+
+- **`getArea(name: string)`**: Returns a scoped logger for a specific logic block.
+- `.info(msg, payload?)`
+- `.warn(msg, payload?)`
+- `.error(msg, error?)`
+
+- **`dump()`**: Returns an object containing all logs indexed by their area names.
+- **`appendLogData(data)`**: Manually injects log entries into the current instance.
+
+---
+
+## 🧪 Development & Testing
+
+This project uses **Vitest** for unit testing.
+
+```bash
+# Run tests
+npm test
+
+# Run tests with coverage
+npm run coverage
+
+```
+
+> **Note:** The logger automatically creates a `root` area log entry labeled "Request received" if a `path` is provided during initialization.

package/dist/index.cjs

@@ -0,0 +1,145 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Logger: () => Logger,
+  createLogger: () => createLogger
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/Logger.ts
+var import_cuid2 = require("@paralleldrive/cuid2");
+
+// src/utils.ts
+var prettyStack = (stack) => {
+  if (!stack) return [];
+  let toReplace = "";
+  const regex = /file:\/\/\/(.*)(\.wrangler|node_modules)\/.*\)/gm;
+  const m = regex.exec(stack);
+  if (m && m.length > 1) {
+    toReplace = m[1];
+  }
+  return stack.split("\n").map((line) => line.trim()).filter((line) => !line.startsWith("Error: ")).map((line) => line.replace(toReplace, "")).map((line) => line.replace("file://", ""));
+};
+var prettyError = (err) => {
+  const stack = prettyStack(err.stack);
+  const message = err.message;
+  return { message, stack };
+};
+var createRootLogEntry = ({
+  path,
+  method,
+  details,
+  eventId,
+  parentEventId,
+  withParentEventId
+}) => {
+  const url = new URL(`http://example.com${path ?? "/"}`);
+  const rootLogEntry = {
+    root: [
+      {
+        type: "info",
+        message: "Request received",
+        payload: {
+          path: `${url.pathname}${url.search}`,
+          method,
+          details,
+          eventId,
+          ...parentEventId && { parentEventId }
+        },
+        timestamp: Date.now()
+      }
+    ]
+  };
+  if (withParentEventId && !parentEventId) {
+    rootLogEntry.root.push({
+      type: "error",
+      message: "Parent event ID expected but not found",
+      timestamp: Date.now()
+    });
+  }
+  return rootLogEntry;
+};
+
+// src/Logger.ts
+var Logger = class {
+  constructor(options) {
+    this.parentEventId = options.parentEventId;
+    this.eventId = (0, import_cuid2.init)({ fingerprint: options.details.service })();
+    this.log = createRootLogEntry({
+      path: options.path || "/",
+      method: options.method,
+      details: options.details,
+      eventId: this.eventId,
+      parentEventId: options.parentEventId,
+      withParentEventId: options.withParentEventId
+    });
+  }
+  // Area function that returns area-specific logger methods
+  getArea(name = "dummy") {
+    if (!this.log[name]) {
+      this.log[name] = [];
+    }
+    return {
+      info: (message, payload) => {
+        this.log[name].push({
+          type: "info",
+          message,
+          payload,
+          timestamp: Date.now()
+        });
+      },
+      warn: (message, payload) => {
+        this.log[name].push({
+          type: "warn",
+          message,
+          payload,
+          timestamp: Date.now()
+        });
+      },
+      error: (message, payload) => {
+        this.log[name].push({
+          type: "error",
+          message,
+          payload: payload instanceof Error ? prettyError(payload) : payload,
+          timestamp: Date.now()
+        });
+      }
+    };
+  }
+  // Public methods on main instance
+  dump() {
+    return this.log;
+  }
+  appendLogData(logData) {
+    delete logData.root;
+    this.log = { ...logData, ...this.log };
+  }
+};
+var createLogger = (options) => {
+  return new Logger(options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Logger,
+  createLogger
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/Logger.ts","../src/utils.ts"],"sourcesContent":["export { Logger, createLogger } from './Logger';\nexport { LogData, LogEntry } from './types';\n","import { init } from '@paralleldrive/cuid2';\nimport { createRootLogEntry, prettyError } from './utils';\nimport { LogData, LoggerOptions, LogEntry } from './types';\n\nexport class Logger {\n  public eventId: string;\n  private log: LogData;\n  public parentEventId?: string;\n\n  constructor(options: LoggerOptions) {\n    this.parentEventId = options.parentEventId;\n    this.eventId = init({ fingerprint: options.details.service })();\n\n    this.log = createRootLogEntry({\n      path: options.path || '/',\n      method: options.method,\n      details: options.details,\n      eventId: this.eventId,\n      parentEventId: options.parentEventId,\n      withParentEventId: options.withParentEventId,\n    });\n  }\n\n  // Area function that returns area-specific logger methods\n  public getArea(name = 'dummy') {\n    if (!this.log[name]) {\n      this.log[name] = [];\n    }\n\n    return {\n      info: (message: string, payload?: LogEntry['payload']) => {\n        this.log[name]!.push({\n          type: 'info',\n          message,\n          payload,\n          timestamp: Date.now(),\n        });\n      },\n      warn: (message: string, payload?: LogEntry['payload']) => {\n        this.log[name]!.push({\n          type: 'warn',\n          message,\n          payload,\n          timestamp: Date.now(),\n        });\n      },\n      error: (message: string, payload?: LogEntry['payload'] | Error) => {\n        this.log[name]!.push({\n          type: 'error',\n          message,\n          payload: payload instanceof Error ? prettyError(payload) : payload,\n          timestamp: Date.now(),\n        });\n      },\n    };\n  }\n\n  // Public methods on main instance\n  public dump(): LogData {\n    return this.log;\n  }\n\n  public appendLogData(logData: LogData): void {\n    delete logData.root;\n    this.log = { ...logData, ...this.log };\n  }\n}\n\n// Factory function for convenience\nexport const createLogger = (options: LoggerOptions): Logger => {\n  return new Logger(options);\n};\n","import { CreateRootLogEntryOptions, LogData, RootPayload } from './types';\n\nexport const prettyStack = (stack?: string): string[] => {\n  if (!stack) return [];\n  let toReplace = '';\n\n  const regex = /file:\\/\\/\\/(.*)(\\.wrangler|node_modules)\\/.*\\)/gm;\n  const m = regex.exec(stack);\n\n  if (m && m.length > 1) {\n    toReplace = m[1];\n  }\n\n  return stack\n    .split('\\n')\n    .map((line) => line.trim())\n    .filter((line) => !line.startsWith('Error: '))\n    .map((line) => line.replace(toReplace, ''))\n    .map((line) => line.replace('file://', ''));\n};\n\nexport const prettyError = (err: Error) => {\n  const stack = prettyStack(err.stack);\n  const message = err.message;\n  return { message, stack };\n};\n\nexport const createRootLogEntry = ({\n  path,\n  method,\n  details,\n  eventId,\n  parentEventId,\n  withParentEventId,\n}: CreateRootLogEntryOptions): LogData => {\n  const url = new URL(`http://example.com${path ?? '/'}`);\n\n  const rootLogEntry: LogData = {\n    root: [\n      {\n        type: 'info',\n        message: 'Request received',\n        payload: {\n          path: `${url.pathname}${url.search}`,\n          method,\n          details,\n          eventId,\n          ...(parentEventId && { parentEventId }),\n        } as RootPayload,\n        timestamp: Date.now(),\n      },\n    ],\n  };\n\n  if (withParentEventId && !parentEventId) {\n    rootLogEntry.root.push({\n      type: 'error',\n      message: 'Parent event ID expected but not found',\n      timestamp: Date.now(),\n    });\n  }\n\n  return rootLogEntry;\n};\n"],"mappings":"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","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,35 @@
+type Details = {
+    service: string;
+} & Record<string, unknown>;
+type Method = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options' | 'trace' | 'connect';
+type LogEntry = {
+    type: 'info' | 'warn' | 'error';
+    message: string;
+    payload?: object;
+    timestamp: number;
+};
+type LogData = Record<string, LogEntry[]>;
+interface LoggerOptions {
+    details: Details;
+    path?: string;
+    parentEventId?: string;
+    withParentEventId?: boolean;
+    method?: Method;
+}
+
+declare class Logger {
+    eventId: string;
+    private log;
+    parentEventId?: string;
+    constructor(options: LoggerOptions);
+    getArea(name?: string): {
+        info: (message: string, payload?: LogEntry["payload"]) => void;
+        warn: (message: string, payload?: LogEntry["payload"]) => void;
+        error: (message: string, payload?: LogEntry["payload"] | Error) => void;
+    };
+    dump(): LogData;
+    appendLogData(logData: LogData): void;
+}
+declare const createLogger: (options: LoggerOptions) => Logger;
+
+export { type LogData, type LogEntry, Logger, createLogger };

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+type Details = {
+    service: string;
+} & Record<string, unknown>;
+type Method = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options' | 'trace' | 'connect';
+type LogEntry = {
+    type: 'info' | 'warn' | 'error';
+    message: string;
+    payload?: object;
+    timestamp: number;
+};
+type LogData = Record<string, LogEntry[]>;
+interface LoggerOptions {
+    details: Details;
+    path?: string;
+    parentEventId?: string;
+    withParentEventId?: boolean;
+    method?: Method;
+}
+
+declare class Logger {
+    eventId: string;
+    private log;
+    parentEventId?: string;
+    constructor(options: LoggerOptions);
+    getArea(name?: string): {
+        info: (message: string, payload?: LogEntry["payload"]) => void;
+        warn: (message: string, payload?: LogEntry["payload"]) => void;
+        error: (message: string, payload?: LogEntry["payload"] | Error) => void;
+    };
+    dump(): LogData;
+    appendLogData(logData: LogData): void;
+}
+declare const createLogger: (options: LoggerOptions) => Logger;
+
+export { type LogData, type LogEntry, Logger, createLogger };