@vingitonga/elysia-winston-logger 0.1.1 → 0.1.2

package/dist/elysiaLogging.d.ts

@@ -0,0 +1,55 @@
+import { Elysia } from 'elysia';
+import type { IPHeaders, Logger, RequestLoggerOptions } from './logger-types';
+/**
+ * List of IP headers to check in order of priority.
+ *
+ * @remarks
+ * The order of the headers in this list determines the priority of the headers to use when determining the client IP address.
+ * If the first header is not present, the second header is checked, and so on.
+ */
+export declare const headersToCheck: IPHeaders[];
+/**
+ * Creates a middleware function that logs incoming requests and outgoing responses.
+ *
+ * @param logger - The logger object to use for logging. Defaults to console.
+ * @param options - The options object to configure the middleware.
+ * @param options.level - The log level to use. Defaults to "info".
+ * @param options.format - The log format to use. Can be a string or a function. Defaults to "json".
+ * @param options.skip - A function that returns true to skip logging for a specific request.
+ * @param options.includeHeaders - An array of headers to include in the log.
+ * @param options.ipHeaders - An array of headers to check for the client IP address.
+ *
+ * @returns A middleware function that logs incoming requests and outgoing responses.
+ */
+export declare function ElysiaLogging(logger?: Logger, options?: RequestLoggerOptions): Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {
+        readonly ip: string | undefined;
+    };
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: import("elysia").ExtractErrorFromHandle<{
+        readonly ip: string | undefined;
+    }> & {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/helpers.d.ts

@@ -0,0 +1,35 @@
+import type { Headers } from 'undici-types';
+import type { BasicAuth, IPHeaders } from './logger-types';
+/**
+ * Parses a Basic Authentication header string and returns an object containing the username and password.
+ *
+ * @param header - The Basic Authentication header string to parse.
+ *
+ * @returns An object containing the username and password, or undefined if the header is invalid.
+ */
+export declare function parseBasicAuthHeader(header: string): BasicAuth | undefined;
+/**
+ * Formats a duration in nanoseconds to a human-readable string.
+ *
+ * @param durationInNanoseconds - The duration in nanoseconds to format.
+ *
+ * @returns A string representing the formatted duration.
+ */
+export declare function formatDuration(durationInNanoseconds: number): string;
+/**
+ * Returns the IP address of the client making the request.
+ *
+ * @param headers - The headers object from the request.
+ * @param ipHeaders - An array of header names to check for the IP address. Defaults to common IP headers.
+ *
+ * @returns The IP address of the client, or undefined if not found.
+ */
+export declare function getIP(headers: Headers, ipHeaders?: IPHeaders[]): string | undefined | null;
+/**
+ * Returns the name of the formatting method for a given format string.
+ *
+ * @param format - The format string to get the formatting method name for.
+ *
+ * @returns The name of the formatting method.
+ */
+export declare function getFormattingMethodName(format: string): string;

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+import { type Logger } from 'winston';
+import { LogFormat } from './logger-types';
+export declare const defaultLogger: Logger;
+export declare const winstonLogger: (customLogger?: Logger, options?: {
+    level?: string;
+    format?: (typeof LogFormat)[keyof typeof LogFormat];
+}) => import("elysia").default<"", {
+    decorator: {};
+    store: {};
+    derive: {
+        readonly ip: string | undefined;
+    };
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: import("elysia").ExtractErrorFromHandle<{
+        readonly ip: string | undefined;
+    }> & {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;