@oneminutelogs/nestjs 1.0.0

package/README.md

@@ -0,0 +1,151 @@
+# @oneminutelogs/nestjs
+
+The official NestJS SDK for [OneMinuteLogs](https://oneminutelogs.com).
+
+This package provides a seamless integration with NestJS, including a Global Module, Service for manual logging, and an Interceptor for automatic request logging.
+
+**Official Documentation:** [oneminutestack.com/docs/nestjs](https://oneminutestack.com/docs/nestjs)
+
+## Features
+
+- **Global Module**: Initialize once, use everywhere via dependency injection.
+- **Interceptor**: Automatically logs every HTTP request with duration, status, and metadata.
+- **Type-Safe Service**: injectable `OneMinuteLogsService` with all typed log methods (`info`, `error`, `audit`, etc.).
+- **Async Configuration**: Support for `forRootAsync` to load config from `ConfigService`.
+
+## Installation
+
+```bash
+npm install @oneminutelogs/nestjs
+# or
+yarn add @oneminutelogs/nestjs
+# or
+pnpm add @oneminutelogs/nestjs
+```
+
+## Quick Start
+
+### 1. Import Module
+
+Import `OneMinuteLogsModule` in your root `AppModule`.
+
+```typescript
+import { Module } from "@nestjs/common";
+import { OneMinuteLogsModule } from "@oneminutelogs/nestjs";
+
+@Module({
+  imports: [
+    OneMinuteLogsModule.forRoot({
+      apiKey: process.env.OML_API_KEY!,
+      appName: "my-nestjs-service",
+      environment: process.env.NODE_ENV || "development"
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+### 2. Automatic Request Logging
+
+Bind the `OneMinuteLogsInterceptor` globally in your `main.ts` or as a global provider.
+
+**Option A: In `main.ts`**
+```typescript
+import { OneMinuteLogsInterceptor, OneMinuteLogsService } from "@oneminutelogs/nestjs";
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  
+  const omlService = app.get(OneMinuteLogsService);
+  app.useGlobalInterceptors(new OneMinuteLogsInterceptor(omlService));
+  
+  await app.listen(3000);
+}
+bootstrap();
+```
+
+**Option B: As a Provider (Recommended)**
+```typescript
+import { Module } from "@nestjs/common";
+import { APP_INTERCEPTOR } from "@nestjs/core";
+import { OneMinuteLogsModule, OneMinuteLogsInterceptor } from "@oneminutelogs/nestjs";
+
+@Module({
+  imports: [
+    OneMinuteLogsModule.forRoot({ /* ... */ }),
+  ],
+  providers: [
+    {
+      provide: APP_INTERCEPTOR,
+      useClass: OneMinuteLogsInterceptor,
+    },
+  ],
+})
+export class AppModule {}
+```
+
+### 3. Manual Logging
+
+Inject `OneMinuteLogsService` into any provider or controller.
+
+```typescript
+import { Injectable } from "@nestjs/common";
+import { OneMinuteLogsService } from "@oneminutelogs/nestjs";
+
+@Injectable()
+export class AuthService {
+  constructor(private readonly logger: OneMinuteLogsService) {}
+
+  async validateUser(username: string) {
+    // Info log
+    await this.logger.info({ message: `Validating user ${username}` });
+    
+    // Security Audit
+    await this.logger.audit({
+      message: "Login attempt",
+      security: {
+        auth_status: "pending",
+        user_id: username
+      }
+    });
+  }
+}
+```
+
+## Async Configuration
+
+If you need to load configuration asynchronously (e.g., from `@nestjs/config`), use `forRootAsync`.
+
+```typescript
+import { ConfigModule, ConfigService } from "@nestjs/config";
+
+OneMinuteLogsModule.forRootAsync({
+  imports: [ConfigModule],
+  useFactory: async (configService: ConfigService) => ({
+    apiKey: configService.getOrThrow("OML_API_KEY"),
+    appName: configService.get("APP_NAME"),
+  }),
+  inject: [ConfigService],
+});
+```
+
+## API Reference
+
+### OneMinuteLogsService
+
+- `info(payload)`
+- `error(payload)`
+- `warning(payload)`
+- `audit(payload)`
+- `metric(payload)`
+- `debug(payload)`
+- `success(payload)`
+- `send(payload)` (Generic)
+- `get(filters)` (Query logs)
+- `stream(filters)` (Stream logs)
+
+---
+
+## Support
+
+If you have any questions or need assistance, please contact us at [contact@oneminutestack.com](mailto:contact@oneminutestack.com).

package/dist/OneMinuteLogsInterceptor.d.ts

@@ -0,0 +1,9 @@
+import { NestInterceptor, ExecutionContext, CallHandler } from "@nestjs/common";
+import { Observable } from "rxjs";
+import { OneMinuteLogsService } from "./OneMinuteLogsService.js";
+export declare class OneMinuteLogsInterceptor implements NestInterceptor {
+    private readonly oml;
+    constructor(oml: OneMinuteLogsService);
+    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
+    private logRequest;
+}

package/dist/OneMinuteLogsInterceptor.js

@@ -0,0 +1,66 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneMinuteLogsInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const operators_1 = require("rxjs/operators");
+const OneMinuteLogsService_js_1 = require("./OneMinuteLogsService.js");
+let OneMinuteLogsInterceptor = class OneMinuteLogsInterceptor {
+    constructor(oml) {
+        this.oml = oml;
+    }
+    intercept(context, next) {
+        const req = context.switchToHttp().getRequest();
+        const res = context.switchToHttp().getResponse();
+        // Safety check for HTTP context
+        if (!req || !res) {
+            return next.handle();
+        }
+        const start = Date.now();
+        const method = req.method;
+        const url = req.originalUrl || req.url;
+        const ip = req.ip || req.socket?.remoteAddress;
+        const userAgent = req.get ? req.get("user-agent") : req.headers["user-agent"];
+        return next.handle().pipe((0, operators_1.tap)({
+            next: () => {
+                this.logRequest(method, url, res.statusCode, Date.now() - start, ip, userAgent);
+            },
+            error: (err) => {
+                // NestJS exception filters usually handle the response status specific logic
+                // But here we can catch the error flow
+                const status = err.status || 500;
+                this.logRequest(method, url, status, Date.now() - start, ip, userAgent, err.message);
+            },
+        }));
+    }
+    logRequest(method, url, statusCode, duration, ip, userAgent, errorMessage) {
+        const isError = statusCode >= 400;
+        const logMethod = isError ? this.oml.error.bind(this.oml) : this.oml.info.bind(this.oml);
+        logMethod({
+            message: `${method} ${url} ${statusCode} - ${duration}ms${errorMessage ? ` [Error: ${errorMessage}]` : ""}`,
+            subsystem: "network",
+            metrics: {
+                duration,
+                statusCode,
+                method,
+            },
+            track: {
+                ip,
+                userAgent,
+            },
+        });
+    }
+};
+exports.OneMinuteLogsInterceptor = OneMinuteLogsInterceptor;
+exports.OneMinuteLogsInterceptor = OneMinuteLogsInterceptor = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [OneMinuteLogsService_js_1.OneMinuteLogsService])
+], OneMinuteLogsInterceptor);

package/dist/OneMinuteLogsModule.d.ts

@@ -0,0 +1,9 @@
+import { DynamicModule } from "@nestjs/common";
+import { LoggerConfig } from "./types/index.js";
+export declare class OneMinuteLogsModule {
+    static forRoot(config: LoggerConfig): DynamicModule;
+    static forRootAsync(options: {
+        useFactory: (...args: any[]) => Promise<LoggerConfig> | LoggerConfig;
+        inject?: any[];
+    }): DynamicModule;
+}

package/dist/OneMinuteLogsModule.js

@@ -0,0 +1,47 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var OneMinuteLogsModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneMinuteLogsModule = void 0;
+const common_1 = require("@nestjs/common");
+const OneMinuteLogsService_js_1 = require("./OneMinuteLogsService.js");
+let OneMinuteLogsModule = OneMinuteLogsModule_1 = class OneMinuteLogsModule {
+    static forRoot(config) {
+        return {
+            module: OneMinuteLogsModule_1,
+            providers: [
+                {
+                    provide: OneMinuteLogsService_js_1.OML_CONFIG,
+                    useValue: config,
+                },
+                OneMinuteLogsService_js_1.OneMinuteLogsService,
+            ],
+            exports: [OneMinuteLogsService_js_1.OneMinuteLogsService],
+        };
+    }
+    static forRootAsync(options) {
+        const providers = [
+            {
+                provide: OneMinuteLogsService_js_1.OML_CONFIG,
+                useFactory: options.useFactory,
+                inject: options.inject || [],
+            },
+            OneMinuteLogsService_js_1.OneMinuteLogsService,
+        ];
+        return {
+            module: OneMinuteLogsModule_1,
+            providers,
+            exports: [OneMinuteLogsService_js_1.OneMinuteLogsService],
+        };
+    }
+};
+exports.OneMinuteLogsModule = OneMinuteLogsModule;
+exports.OneMinuteLogsModule = OneMinuteLogsModule = OneMinuteLogsModule_1 = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({})
+], OneMinuteLogsModule);

package/dist/OneMinuteLogsService.d.ts

@@ -0,0 +1,28 @@
+import { LoggerConfig, LogPayload } from "./types/index.js";
+export declare const OML_CONFIG = "OML_CONFIG";
+export declare class OneMinuteLogsService {
+    private config;
+    private logger;
+    constructor(config: LoggerConfig);
+    /**
+     * Send a generic log payload.
+     */
+    send(payload: LogPayload): Promise<void>;
+    info(payload: Omit<LogPayload, "type">): Promise<void>;
+    error(payload: Omit<LogPayload, "type">): Promise<void>;
+    warning(payload: Omit<LogPayload, "type">): Promise<void>;
+    audit(payload: Omit<LogPayload, "type">): Promise<void>;
+    metric(payload: Omit<LogPayload, "type">): Promise<void>;
+    debug(payload: Omit<LogPayload, "type">): Promise<void>;
+    success(payload: Omit<LogPayload, "type">): Promise<void>;
+    /**
+     * Get historical logs.
+     */
+    get(filters?: Record<string, any>): Promise<any>;
+    /**
+     * Stream live logs.
+     */
+    stream(filters: Record<string, any>): {
+        body: ReadableStream<Uint8Array> | null;
+    };
+}

package/dist/OneMinuteLogsService.js

@@ -0,0 +1,69 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneMinuteLogsService = exports.OML_CONFIG = void 0;
+const common_1 = require("@nestjs/common");
+const createLogger_js_1 = require("./core/createLogger.js");
+exports.OML_CONFIG = "OML_CONFIG";
+let OneMinuteLogsService = class OneMinuteLogsService {
+    constructor(config) {
+        this.config = config;
+        this.logger = (0, createLogger_js_1.createLogger)(config);
+    }
+    /**
+     * Send a generic log payload.
+     */
+    async send(payload) {
+        return this.logger.send(payload);
+    }
+    async info(payload) {
+        return this.logger.info(payload);
+    }
+    async error(payload) {
+        return this.logger.error(payload);
+    }
+    async warning(payload) {
+        return this.logger.warning(payload);
+    }
+    async audit(payload) {
+        return this.logger.audit(payload);
+    }
+    async metric(payload) {
+        return this.logger.metric(payload);
+    }
+    async debug(payload) {
+        return this.logger.debug(payload);
+    }
+    async success(payload) {
+        return this.logger.success(payload);
+    }
+    /**
+     * Get historical logs.
+     */
+    async get(filters) {
+        return this.logger.get(filters);
+    }
+    /**
+     * Stream live logs.
+     */
+    stream(filters) {
+        return this.logger.stream(filters);
+    }
+};
+exports.OneMinuteLogsService = OneMinuteLogsService;
+exports.OneMinuteLogsService = OneMinuteLogsService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(exports.OML_CONFIG)),
+    __metadata("design:paramtypes", [Object])
+], OneMinuteLogsService);

package/dist/configs/index.d.ts

@@ -0,0 +1,4 @@
+export interface EnvConfig {
+    baseUrl: string;
+}
+export declare const getEnvConfig: () => EnvConfig;

package/dist/configs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEnvConfig = void 0;
+const getEnvConfig = () => {
+    return {
+        baseUrl: "https://api.oneminutelogs.com/v1/api",
+    };
+};
+exports.getEnvConfig = getEnvConfig;

package/dist/core/createLogger.d.ts

@@ -0,0 +1,37 @@
+/**
+ * oneminutelogs – createLogger
+ *
+ * Summary:
+ * Factory that creates a typed logger backed by OMLTransport. Provides:
+ * - `send` for generic logging
+ * - type helpers: `info`, `error`, `metric`, `audit`, `warning`
+ * - passthrough `get` and `stream` to query historical logs and subscribe to live logs
+ *
+ * Package: @oneminutelogs/express
+ * Module: core/createLogger
+ */
+import type { LoggerConfig, LogPayload } from "../types/index.js";
+/**
+ * Creates a logger bound to an OML transport.
+ *
+ * Behavior:
+ * - Enriches payloads with `appName` and `environment` from config when not provided.
+ * - Defaults `type` to "info" when `send` is called without an explicit type.
+ *
+ * @param config Configuration with `apiKey` and optional `appName`, `environment`.
+ * @returns Logger API with `send`, type helpers, `get`, and `stream`.
+ */
+export declare function createLogger(config: LoggerConfig): {
+    send: (payload: LogPayload) => Promise<void>;
+    info: (payload: Omit<LogPayload, "type">) => Promise<void>;
+    error: (payload: Omit<LogPayload, "type">) => Promise<void>;
+    metric: (payload: Omit<LogPayload, "type">) => Promise<void>;
+    audit: (payload: Omit<LogPayload, "type">) => Promise<void>;
+    warning: (payload: Omit<LogPayload, "type">) => Promise<void>;
+    debug: (payload: Omit<LogPayload, "type">) => Promise<void>;
+    success: (payload: Omit<LogPayload, "type">) => Promise<void>;
+    get: (filters?: Record<string, any>) => Promise<any>;
+    stream: (filters: Record<string, any>) => {
+        body: ReadableStream<Uint8Array> | null;
+    };
+};

package/dist/core/createLogger.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * oneminutelogs – createLogger
+ *
+ * Summary:
+ * Factory that creates a typed logger backed by OMLTransport. Provides:
+ * - `send` for generic logging
+ * - type helpers: `info`, `error`, `metric`, `audit`, `warning`
+ * - passthrough `get` and `stream` to query historical logs and subscribe to live logs
+ *
+ * Package: @oneminutelogs/express
+ * Module: core/createLogger
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+const transport_js_1 = require("../utils/transport.js");
+/**
+ * Creates a logger bound to an OML transport.
+ *
+ * Behavior:
+ * - Enriches payloads with `appName` and `environment` from config when not provided.
+ * - Defaults `type` to "info" when `send` is called without an explicit type.
+ *
+ * @param config Configuration with `apiKey` and optional `appName`, `environment`.
+ * @returns Logger API with `send`, type helpers, `get`, and `stream`.
+ */
+function createLogger(config) {
+    const transport = new transport_js_1.OMLTransport(config);
+    /**
+     * Sends a log payload.
+     *
+     * Merges defaults:
+     * - `type`: defaults to "info"
+     * - `appName`: `payload.appName || config.appName || "default"`
+     * - `environment`: `payload.environment || config.environment || process.env.NODE_ENV || "development"`
+     *
+     * @param payload Log payload to send.
+     * @returns Promise that resolves when the payload is enqueued/flushed.
+     */
+    const send = async (payload) => {
+        const { type = "info", message, importance, subsystem, operation, service, track, security, metrics, timestamps, appName, environment, } = payload;
+        const finalPayload = {
+            type,
+            message,
+            importance,
+            subsystem,
+            operation,
+            service,
+            track,
+            security,
+            metrics,
+            timestamps,
+            appName: appName || config.appName || "default",
+            environment: environment ||
+                config.environment ||
+                process.env.NODE_ENV ||
+                "development",
+        };
+        await transport.send(finalPayload);
+    };
+    // Helper factory to create type-specific methods dynamically
+    /**
+     * Factory for type-specific logging methods (e.g., `info`, `error`).
+     *
+     * @param type Log type to set on the outgoing payload.
+     * @returns Function that accepts a payload without `type` and sends it with the provided `type`.
+     */
+    const createTypeMethod = (type) => (payload) => send({ ...payload, type });
+    /**
+     * Returned API:
+     * - `send(payload)`: send a generic log (defaults `type` to "info").
+     * - `info(payload)`, `error(payload)`, `metric(payload)`, `audit(payload)`, `warning(payload)`: type-specific helpers.
+     * - `get(filters?)`: fetch historical logs via transport.
+     * - `stream(filters?)`: open SSE stream via transport.
+     */
+    return {
+        send,
+        info: createTypeMethod("info"),
+        error: createTypeMethod("error"),
+        metric: createTypeMethod("metric"),
+        audit: createTypeMethod("audit"),
+        warning: createTypeMethod("warning"),
+        debug: createTypeMethod("debug"),
+        success: createTypeMethod("success"),
+        get: (filters) => transport.get(filters),
+        stream: (filters) => transport.stream(filters),
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types/index.js";
+export * from "./OneMinuteLogsService.js";
+export * from "./OneMinuteLogsModule.js";
+export * from "./OneMinuteLogsInterceptor.js";
+export { createLogger } from "./core/createLogger.js";
+export { getLogs } from "./utils/getLogs.js";
+export { getStream } from "./utils/getStream.js";

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStream = exports.getLogs = exports.createLogger = void 0;
+__exportStar(require("./types/index.js"), exports);
+__exportStar(require("./OneMinuteLogsService.js"), exports);
+__exportStar(require("./OneMinuteLogsModule.js"), exports);
+__exportStar(require("./OneMinuteLogsInterceptor.js"), exports);
+var createLogger_js_1 = require("./core/createLogger.js");
+Object.defineProperty(exports, "createLogger", { enumerable: true, get: function () { return createLogger_js_1.createLogger; } });
+var getLogs_js_1 = require("./utils/getLogs.js");
+Object.defineProperty(exports, "getLogs", { enumerable: true, get: function () { return getLogs_js_1.getLogs; } });
+var getStream_js_1 = require("./utils/getStream.js");
+Object.defineProperty(exports, "getStream", { enumerable: true, get: function () { return getStream_js_1.getStream; } });

package/dist/types/index.d.ts

@@ -0,0 +1,30 @@
+import { LogTimestamps } from "./log.js";
+import { LogMetrics } from "./metrics.js";
+import { LogSecurity } from "./security.js";
+import { LogTrack } from "./track.js";
+export type LogLevel = "info" | "warn" | "error";
+export interface LoggerConfig {
+    apiKey: string;
+    appName?: string;
+    environment?: string;
+}
+export interface LogPayload {
+    type: LogType;
+    message: string;
+    importance?: Importance;
+    subsystem?: Subsystem;
+    operation?: string;
+    track?: LogTrack;
+    security?: LogSecurity;
+    metrics?: LogMetrics;
+    service?: string;
+    timestamps?: LogTimestamps;
+    ingested_at?: number;
+    appName?: string;
+    environment?: string;
+}
+export type LogType = "error" | "warning" | "info" | "audit" | "metric" | "debug" | "success";
+export type Importance = "critical" | "high" | "medium" | "low";
+export type Subsystem = "db" | "cache" | "queue" | "network";
+export type UserRole = "super-admin" | "admin" | "user";
+export type AuthStatus = "success" | "failed" | "expired";

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/log.d.ts

@@ -0,0 +1,4 @@
+export type LogTimestamps = Record<string, number | string>;
+export type LogMetrics = Record<string, number | string>;
+export type LogSecurity = Record<string, any>;
+export type LogTrack = Record<string, any>;

package/dist/types/log.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/metrics.d.ts

@@ -0,0 +1 @@
+export type LogMetrics = Record<string, number | string | Record<string, any>>;

package/dist/types/metrics.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/security.d.ts

@@ -0,0 +1 @@
+export type LogSecurity = Record<string, any>;

package/dist/types/security.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/track.d.ts

@@ -0,0 +1 @@
+export type LogTrack = Record<string, any>;

package/dist/types/track.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/getLogs.d.ts

@@ -0,0 +1,26 @@
+/**
+ * oneminutelogs – getLogs utility
+ *
+ * Summary:
+ * A utility function to fetch logs from the OML server.
+ * Unlike the Next.js SDK, this is not a hook but a plain async function.
+ *
+ * Package: @oneminutelogs/express
+ * Module: utils/getLogs
+ */
+import type { LoggerConfig } from "../types/index.js";
+/**
+ * Result returned by `getLogs`.
+ * Wraps the server response.
+ */
+export type GetLogsResult<T = any> = T[] | {
+    logs: T[];
+};
+/**
+ * Fetches logs from the OML server.
+ *
+ * @param config - Logger configuration (apiKey is required).
+ * @param filters - Optional filters (type, limit, search, etc.).
+ * @returns Promise resolving to the logs.
+ */
+export declare function getLogs<T = any>(config: LoggerConfig, filters?: Record<string, any>): Promise<GetLogsResult<T>>;

package/dist/utils/getLogs.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * oneminutelogs – getLogs utility
+ *
+ * Summary:
+ * A utility function to fetch logs from the OML server.
+ * Unlike the Next.js SDK, this is not a hook but a plain async function.
+ *
+ * Package: @oneminutelogs/express
+ * Module: utils/getLogs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogs = getLogs;
+const transport_js_1 = require("./transport.js");
+/**
+ * Fetches logs from the OML server.
+ *
+ * @param config - Logger configuration (apiKey is required).
+ * @param filters - Optional filters (type, limit, search, etc.).
+ * @returns Promise resolving to the logs.
+ */
+async function getLogs(config, filters) {
+    const transport = new transport_js_1.OMLTransport(config);
+    return transport.get(filters);
+}

package/dist/utils/getStream.d.ts

@@ -0,0 +1,21 @@
+/**
+ * oneminutelogs – getStream utility
+ *
+ * Summary:
+ * A utility function to subscribe to the OML server SSE stream.
+ * Returns a ReadableStream of bytes.
+ *
+ * Package: @oneminutelogs/express
+ * Module: utils/getStream
+ */
+import type { LoggerConfig } from "../types/index.js";
+/**
+ * Subscribes to the OML SSE stream.
+ *
+ * @param config - Logger configuration (apiKey is required).
+ * @param filters - Optional filters (type, limit, search, etc.).
+ * @returns Object containing the body stream.
+ */
+export declare function getStream(config: LoggerConfig, filters: Record<string, any>): {
+    body: ReadableStream<Uint8Array> | null;
+};

package/dist/utils/getStream.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * oneminutelogs – getStream utility
+ *
+ * Summary:
+ * A utility function to subscribe to the OML server SSE stream.
+ * Returns a ReadableStream of bytes.
+ *
+ * Package: @oneminutelogs/express
+ * Module: utils/getStream
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStream = getStream;
+const transport_js_1 = require("./transport.js");
+/**
+ * Subscribes to the OML SSE stream.
+ *
+ * @param config - Logger configuration (apiKey is required).
+ * @param filters - Optional filters (type, limit, search, etc.).
+ * @returns Object containing the body stream.
+ */
+function getStream(config, filters) {
+    const transport = new transport_js_1.OMLTransport(config);
+    return transport.stream(filters);
+}

package/dist/utils/transport.d.ts

@@ -0,0 +1,63 @@
+/**
+ * oneminutelogs – OMLTransport
+ *
+ * Summary:
+ * A thin transport client used by oneminutelogs SDK to:
+ * - batch and send logs to the OML server (`/send`)
+ * - query historical logs (`/logs`)
+ * - subscribe to live logs stream via SSE (`/logs/stream`)
+ *
+ * Package: @oneminutelogs/express
+ * Module: utils/transport
+ */
+import type { LoggerConfig, LogPayload } from "../types/index.js";
+/**
+ * Transport for communicating with the OML server.
+ *
+ * Responsibilities:
+ * - Buffers logs client-side and flushes by interval or batch size.
+ * - Sends logs to `/send`.
+ * - Retrieves logs from `/logs` with optional filters.
+ * - Opens SSE stream from `/logs/stream`.
+ */
+export declare class OMLTransport {
+    private config;
+    /** Base server URL (depends on env config). */
+    private baseUrl;
+    /** API key used for authentication (x-oml-api-key). */
+    private apiKey;
+    /** Optional app name used to tag requests (x-oml-app-name). */
+    private appName;
+    /** Optional environment used to tag requests (x-oml-env). */
+    private environment;
+    /** Default headers applied to outbound requests. */
+    private headers;
+    /** In-memory buffer of logs to batch-send. */
+    private buffer;
+    /** Scheduled timer for periodic flushes. */
+    private timer;
+    /** Flush interval in milliseconds for buffered logs. */
+    private flushInterval;
+    /** Indicates shutdown is in progress and new logs should be ignored. */
+    private shuttingDown;
+    /** Indicates whether a flush is currently in progress. */
+    private isFlushing;
+    /**
+     * Creates a new transport instance.
+     *
+     * @param config Logger configuration containing `apiKey`, and optionally `appName` and `environment`.
+     */
+    constructor(config: LoggerConfig);
+    /** Queues a single log payload for sending. */
+    send(payload: LogPayload): Promise<void>;
+    /** Flushes the in-memory buffer to the server as a single batch. */
+    private flush;
+    /** Registers process-level handlers (SIGINT, SIGTERM, beforeExit) */
+    private setupGracefulShutdown;
+    /** Retrieves historical logs from the server. */
+    get(filters?: Record<string, any>): Promise<any>;
+    /** Opens a Server-Sent Events (SSE) stream of live logs. */
+    stream(filters: Record<string, string>): {
+        body: ReadableStream<Uint8Array> | null;
+    };
+}

package/dist/utils/transport.js

@@ -0,0 +1,185 @@
+"use strict";
+/**
+ * oneminutelogs – OMLTransport
+ *
+ * Summary:
+ * A thin transport client used by oneminutelogs SDK to:
+ * - batch and send logs to the OML server (`/send`)
+ * - query historical logs (`/logs`)
+ * - subscribe to live logs stream via SSE (`/logs/stream`)
+ *
+ * Package: @oneminutelogs/express
+ * Module: utils/transport
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OMLTransport = void 0;
+const index_js_1 = require("../configs/index.js");
+/**
+ * Transport for communicating with the OML server.
+ *
+ * Responsibilities:
+ * - Buffers logs client-side and flushes by interval or batch size.
+ * - Sends logs to `/send`.
+ * - Retrieves logs from `/logs` with optional filters.
+ * - Opens SSE stream from `/logs/stream`.
+ */
+class OMLTransport {
+    /**
+     * Creates a new transport instance.
+     *
+     * @param config Logger configuration containing `apiKey`, and optionally `appName` and `environment`.
+     */
+    constructor(config) {
+        this.config = config;
+        /** In-memory buffer of logs to batch-send. */
+        this.buffer = [];
+        /** Scheduled timer for periodic flushes. */
+        this.timer = null;
+        /** Flush interval in milliseconds for buffered logs. */
+        this.flushInterval = 2000;
+        /** Indicates shutdown is in progress and new logs should be ignored. */
+        this.shuttingDown = false;
+        /** Indicates whether a flush is currently in progress. */
+        this.isFlushing = false;
+        const envConfig = (0, index_js_1.getEnvConfig)();
+        this.baseUrl = envConfig.baseUrl;
+        this.apiKey = config.apiKey;
+        this.appName = config.appName;
+        this.environment = config.environment;
+        this.headers = {
+            "Content-Type": "application/json",
+            "x-oml-api-key": config.apiKey,
+            ...(config.appName ? { "x-oml-app-name": config.appName } : {}),
+            ...(config.environment ? { "x-oml-env": config.environment } : {}),
+        };
+        this.setupGracefulShutdown();
+    }
+    /** Queues a single log payload for sending. */
+    async send(payload) {
+        if (this.shuttingDown)
+            return; // ignore new logs during shutdown
+        this.buffer.push({
+            ...payload,
+            ingested_at: Date.now(),
+        });
+        // Rely on the 2s periodic flush
+        if (!this.timer) {
+            this.timer = setTimeout(() => this.flush(), this.flushInterval);
+        }
+    }
+    /** Flushes the in-memory buffer to the server as a single batch. */
+    async flush() {
+        // Prevent multiple flushes from running simultaneously.
+        if (this.isFlushing)
+            return;
+        this.isFlushing = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        const batch = this.buffer.splice(0, this.buffer.length);
+        if (batch.length === 0) {
+            this.isFlushing = false;
+            return;
+        }
+        try {
+            await fetch(`${this.baseUrl}/send`, {
+                method: "POST",
+                headers: this.headers,
+                body: JSON.stringify({ logs: batch }),
+                // @ts-ignore: keepalive might not be in all fetch types, but supported in modern node
+                keepalive: true,
+            });
+        }
+        catch (err) {
+            console.error("OMLTransport flush failed:", err);
+        }
+        this.isFlushing = false;
+    }
+    /** Registers process-level handlers (SIGINT, SIGTERM, beforeExit) */
+    setupGracefulShutdown() {
+        const shutdownHandler = async (signal) => {
+            if (this.shuttingDown)
+                return;
+            this.shuttingDown = true;
+            try {
+                await this.flush();
+            }
+            catch (err) {
+                console.error("[OMLTransport] Flush during shutdown failed:", err);
+            }
+            finally {
+                process.exit(0);
+            }
+        };
+        process.on("beforeExit", () => shutdownHandler("beforeExit"));
+        process.on("SIGINT", () => shutdownHandler("SIGINT"));
+        process.on("SIGTERM", () => shutdownHandler("SIGTERM"));
+    }
+    /** Retrieves historical logs from the server. */
+    async get(filters) {
+        const headers = {
+            "x-oml-api-key": this.apiKey,
+            ...(this.appName ? { "x-oml-app-name": this.appName } : {}),
+            ...(this.environment ? { "x-oml-env": this.environment } : {}),
+        };
+        const qs = filters && Object.keys(filters).length > 0
+            ? `?${new URLSearchParams(filters).toString()}`
+            : "";
+        const res = await fetch(`${this.baseUrl}/logs${qs}`, { headers });
+        if (!res.ok) {
+            const text = await res.text();
+            throw new Error(`OML get failed (${res.status}): ${text.slice(0, 200)}`);
+        }
+        return res.json();
+    }
+    /** Opens a Server-Sent Events (SSE) stream of live logs. */
+    stream(filters) {
+        const qs = new URLSearchParams(filters).toString();
+        const url = `${this.baseUrl}/logs/stream?${qs}`;
+        const headers = {
+            "x-oml-api-key": this.apiKey,
+            ...(this.appName ? { "x-oml-app-name": this.appName } : {}),
+            ...(this.environment ? { "x-oml-env": this.environment } : {}),
+        };
+        const abortController = new AbortController();
+        // In node-fetch or native fetch, response.body is a stream. 
+        // We return a wrapped object to match similar API pattern or just return the fetch promise.
+        // However, to keep it sync-like wrapper (returning stream object immediately), we can't do await fetch.
+        // The original code was async inside ReadableStream start.
+        // For Node.js consumption, we probably want a simpler async method or return the promise of the stream.
+        // But adhering to the interface:
+        const readable = new ReadableStream({
+            start: async (controller) => {
+                try {
+                    const res = await fetch(url, {
+                        headers,
+                        signal: abortController.signal,
+                    });
+                    if (!res.body) {
+                        controller.error(new Error("Upstream stream unavailable"));
+                        return;
+                    }
+                    // @ts-ignore
+                    const reader = res.body.getReader();
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        if (value)
+                            controller.enqueue(value);
+                    }
+                    controller.close();
+                }
+                catch (err) {
+                    controller.error(err);
+                }
+            },
+            cancel() {
+                abortController.abort();
+            },
+        });
+        return { body: readable };
+    }
+}
+exports.OMLTransport = OMLTransport;

package/package.json

@@ -0,0 +1,55 @@
+{
+    "name": "@oneminutelogs/nestjs",
+    "version": "1.0.0",
+    "description": "NestJS SDK for OneMinuteLogs",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
+        }
+    },
+    "scripts": {
+        "build": "tsc",
+        "clean": "rm -rf dist",
+        "prepublishOnly": "npm run clean && npm run build"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/One-Minute-Stack/oneminutelogs-nestjs.git"
+    },
+    "keywords": [
+        "logging",
+        "nestjs",
+        "oneminutelogs",
+        "logger",
+        "monitoring",
+        "observability"
+    ],
+    "author": "OneMinute Stack",
+    "license": "ISC",
+    "bugs": {
+        "url": "https://github.com/One-Minute-Stack/oneminutelogs-nestjs/issues"
+    },
+    "homepage": "https://oneminutelogs.com/docs/nestjs",
+    "peerDependencies": {
+        "@nestjs/common": "^8.0.0 || ^9.0.0 || ^10.0.0",
+        "@nestjs/core": "^8.0.0 || ^9.0.0 || ^10.0.0",
+        "rxjs": "^7.0.0"
+    },
+    "devDependencies": {
+        "@nestjs/common": "^10.0.0",
+        "@nestjs/core": "^10.0.0",
+        "@types/node": "^20.0.0",
+        "reflect-metadata": "^0.1.13",
+        "rxjs": "^7.8.1",
+        "typescript": "^5.0.0"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}