@lssm/lib.logger 1.42.0 → 1.42.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Chaman Ventures, SASU
+
+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

@@ -1,5 +1,8 @@
 # @lssm/lib.logger
 
+Website: https://contractspec.lssm.tech/
+
+
 High-performance logging library optimized for Bun, with native ElysiaJS integration.
 
 ## Purpose

package/dist/context.browser.d.mts

@@ -0,0 +1,49 @@
+import { ContextData, TraceContext } from "./types.mjs";
+import "zone.js";
+
+//#region src/context.browser.d.ts
+
+/**
+ * Browser implementation of LogContext using Zone.js for async context
+ * propagation (similar to AsyncLocalStorage in Node).
+ */
+declare class LogContext {
+  private static instance;
+  private static fallbackCounter;
+  static getInstance(): LogContext;
+  /**
+   * Run a function with a new context
+   */
+  run<T>(context: ContextData, fn: () => T): T;
+  /**
+   * Run a function with an extended context (merges with current)
+   */
+  extend<T>(additionalContext: Partial<ContextData>, fn: () => T): T;
+  /**
+   * Set context data for the current execution context
+   */
+  set(key: string, value: unknown): void;
+  /**
+   * Get a specific context value
+   */
+  get<T>(key: string): T | undefined;
+  /**
+   * Get all context data
+   */
+  getContext(): ContextData;
+  /**
+   * Set trace context
+   */
+  setTrace(trace: TraceContext): void;
+  /**
+   * Get current trace context
+   */
+  getCurrentTrace(): TraceContext | undefined;
+  /**
+   * Generate a unique ID for requests/operations
+   */
+  generateId(): string;
+}
+//#endregion
+export { LogContext };
+//# sourceMappingURL=context.browser.d.mts.map

package/dist/context.browser.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.browser.d.mts","names":[],"sources":["../src/context.browser.ts"],"sourcesContent":[],"mappings":";;;;;;;AAmCA;;AAckB,cAdL,UAAA,CAcK;EAAuB,eAAA,QAAA;EAAI,eAAA,eAAA;EAqBN,OAAA,WAAA,CAAA,CAAA,EA/Bf,UA+Be;EAAR;;;EAsBR,GAAA,CAAA,CAAA,CAAA,CAAA,OAAA,EA3CL,WA2CK,EAAA,EAAA,EAAA,GAAA,GA3CkB,CA2ClB,CAAA,EA3CsB,CA2CtB;EAQP;;;EAkBiB,MAAA,CAAA,CAAA,CAAA,CAAA,iBAAA,EAhDF,OAgDE,CAhDM,WAgDN,CAAA,EAAA,EAAA,EAAA,GAAA,GAhD8B,CAgD9B,CAAA,EAhDkC,CAgDlC;;;;;;;;uBA1BV;;;;gBAQP;;;;kBAQE;;;;qBAUG"}

package/dist/context.browser.mjs

@@ -1 +1,89 @@
-import"zone.js";const e=globalThis.Zone,t=`__lssm_log_context_data__`;function n(){if(e)return e.current.get(t)}var r=class r{static instance;static fallbackCounter=0;static getInstance(){return r.instance||=new r,r.instance}run(n,r){let i={context:{...n},trace:this.getCurrentTrace()};return e?e.current.fork({name:`log-context`,properties:{[t]:i}}).run(r):r()}extend(e,t){let n={...this.getContext(),...e};return this.run(n,t)}set(e,t){let r=n();r&&(r.context[e]=t)}get(e){return n()?.context?.[e]}getContext(){return n()?.context||{}}setTrace(e){let t=n();t&&(t.trace=e)}getCurrentTrace(){return n()?.trace}generateId(){return typeof crypto<`u`&&typeof crypto.randomUUID==`function`?crypto.randomUUID():(r.fallbackCounter+=1,`log-${r.fallbackCounter}`)}};export{r as LogContext};
+import "zone.js";
+
+//#region src/context.browser.ts
+const ZONE = globalThis.Zone;
+const STORE_KEY = "__lssm_log_context_data__";
+function getStore() {
+	if (!ZONE) return void 0;
+	return ZONE.current.get(STORE_KEY);
+}
+/**
+* Browser implementation of LogContext using Zone.js for async context
+* propagation (similar to AsyncLocalStorage in Node).
+*/
+var LogContext = class LogContext {
+	static instance;
+	static fallbackCounter = 0;
+	static getInstance() {
+		if (!LogContext.instance) LogContext.instance = new LogContext();
+		return LogContext.instance;
+	}
+	/**
+	* Run a function with a new context
+	*/
+	run(context, fn) {
+		const contextData = {
+			context: { ...context },
+			trace: this.getCurrentTrace()
+		};
+		if (!ZONE) return fn();
+		return ZONE.current.fork({
+			name: "log-context",
+			properties: { [STORE_KEY]: contextData }
+		}).run(fn);
+	}
+	/**
+	* Run a function with an extended context (merges with current)
+	*/
+	extend(additionalContext, fn) {
+		const mergedContext = {
+			...this.getContext(),
+			...additionalContext
+		};
+		return this.run(mergedContext, fn);
+	}
+	/**
+	* Set context data for the current execution context
+	*/
+	set(key, value) {
+		const current = getStore();
+		if (current) current.context[key] = value;
+	}
+	/**
+	* Get a specific context value
+	*/
+	get(key) {
+		return getStore()?.context?.[key];
+	}
+	/**
+	* Get all context data
+	*/
+	getContext() {
+		return getStore()?.context || {};
+	}
+	/**
+	* Set trace context
+	*/
+	setTrace(trace) {
+		const current = getStore();
+		if (current) current.trace = trace;
+	}
+	/**
+	* Get current trace context
+	*/
+	getCurrentTrace() {
+		return getStore()?.trace;
+	}
+	/**
+	* Generate a unique ID for requests/operations
+	*/
+	generateId() {
+		if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+		LogContext.fallbackCounter += 1;
+		return `log-${LogContext.fallbackCounter}`;
+	}
+};
+
+//#endregion
+export { LogContext };
+//# sourceMappingURL=context.browser.mjs.map

package/dist/context.browser.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.browser.mjs","names":["contextData: LogContextData","mergedContext: ContextData"],"sources":["../src/context.browser.ts"],"sourcesContent":["import 'zone.js';\nimport type { ContextData, TraceContext } from './types';\n\ninterface LogContextData {\n  context: ContextData;\n  trace?: TraceContext;\n}\n\ninterface ZoneForkSpec {\n  name?: string;\n  properties?: Record<string, unknown>;\n}\n\ninterface ZoneLike {\n  fork(spec: ZoneForkSpec): ZoneLike;\n  run<T>(fn: () => T): T;\n  get<T>(key: string): T | undefined;\n}\n\ninterface ZoneStaticLike {\n  current: ZoneLike;\n}\n\nconst ZONE = (globalThis as unknown as { Zone?: ZoneStaticLike }).Zone;\nconst STORE_KEY = '__lssm_log_context_data__';\n\nfunction getStore(): LogContextData | undefined {\n  if (!ZONE) return undefined;\n  return ZONE.current.get<LogContextData>(STORE_KEY);\n}\n\n/**\n * Browser implementation of LogContext using Zone.js for async context\n * propagation (similar to AsyncLocalStorage in Node).\n */\nexport class LogContext {\n  private static instance: LogContext;\n  private static fallbackCounter = 0;\n\n  static getInstance(): LogContext {\n    if (!LogContext.instance) {\n      LogContext.instance = new LogContext();\n    }\n    return LogContext.instance;\n  }\n\n  /**\n   * Run a function with a new context\n   */\n  run<T>(context: ContextData, fn: () => T): T {\n    const contextData: LogContextData = {\n      context: { ...context },\n      trace: this.getCurrentTrace(),\n    };\n\n    if (!ZONE) {\n      return fn();\n    }\n\n    const zone = ZONE.current.fork({\n      name: 'log-context',\n      properties: { [STORE_KEY]: contextData },\n    });\n\n    return zone.run(fn);\n  }\n\n  /**\n   * Run a function with an extended context (merges with current)\n   */\n  extend<T>(additionalContext: Partial<ContextData>, fn: () => T): T {\n    const currentContext = this.getContext();\n    const mergedContext: ContextData = {\n      ...currentContext,\n      ...additionalContext,\n    };\n    return this.run(mergedContext, fn);\n  }\n\n  /**\n   * Set context data for the current execution context\n   */\n  set(key: string, value: unknown): void {\n    const current = getStore();\n    if (current) {\n      current.context[key] = value;\n    }\n  }\n\n  /**\n   * Get a specific context value\n   */\n  get<T>(key: string): T | undefined {\n    const current = getStore();\n    return current?.context?.[key] as T | undefined;\n  }\n\n  /**\n   * Get all context data\n   */\n  getContext(): ContextData {\n    const current = getStore();\n    return current?.context || {};\n  }\n\n  /**\n   * Set trace context\n   */\n  setTrace(trace: TraceContext): void {\n    const current = getStore();\n    if (current) {\n      current.trace = trace;\n    }\n  }\n\n  /**\n   * Get current trace context\n   */\n  getCurrentTrace(): TraceContext | undefined {\n    const current = getStore();\n    return current?.trace;\n  }\n\n  /**\n   * Generate a unique ID for requests/operations\n   */\n  generateId(): string {\n    if (\n      typeof crypto !== 'undefined' &&\n      typeof (crypto as unknown as { randomUUID?: unknown }).randomUUID ===\n        'function'\n    ) {\n      return crypto.randomUUID();\n    }\n\n    LogContext.fallbackCounter += 1;\n    return `log-${LogContext.fallbackCounter}`;\n  }\n}\n"],"mappings":";;;AAuBA,MAAM,OAAQ,WAAoD;AAClE,MAAM,YAAY;AAElB,SAAS,WAAuC;AAC9C,KAAI,CAAC,KAAM,QAAO;AAClB,QAAO,KAAK,QAAQ,IAAoB,UAAU;;;;;;AAOpD,IAAa,aAAb,MAAa,WAAW;CACtB,OAAe;CACf,OAAe,kBAAkB;CAEjC,OAAO,cAA0B;AAC/B,MAAI,CAAC,WAAW,SACd,YAAW,WAAW,IAAI,YAAY;AAExC,SAAO,WAAW;;;;;CAMpB,IAAO,SAAsB,IAAgB;EAC3C,MAAMA,cAA8B;GAClC,SAAS,EAAE,GAAG,SAAS;GACvB,OAAO,KAAK,iBAAiB;GAC9B;AAED,MAAI,CAAC,KACH,QAAO,IAAI;AAQb,SALa,KAAK,QAAQ,KAAK;GAC7B,MAAM;GACN,YAAY,GAAG,YAAY,aAAa;GACzC,CAAC,CAEU,IAAI,GAAG;;;;;CAMrB,OAAU,mBAAyC,IAAgB;EAEjE,MAAMC,gBAA6B;GACjC,GAFqB,KAAK,YAAY;GAGtC,GAAG;GACJ;AACD,SAAO,KAAK,IAAI,eAAe,GAAG;;;;;CAMpC,IAAI,KAAa,OAAsB;EACrC,MAAM,UAAU,UAAU;AAC1B,MAAI,QACF,SAAQ,QAAQ,OAAO;;;;;CAO3B,IAAO,KAA4B;AAEjC,SADgB,UAAU,EACV,UAAU;;;;;CAM5B,aAA0B;AAExB,SADgB,UAAU,EACV,WAAW,EAAE;;;;;CAM/B,SAAS,OAA2B;EAClC,MAAM,UAAU,UAAU;AAC1B,MAAI,QACF,SAAQ,QAAQ;;;;;CAOpB,kBAA4C;AAE1C,SADgB,UAAU,EACV;;;;;CAMlB,aAAqB;AACnB,MACE,OAAO,WAAW,eAClB,OAAQ,OAA+C,eACrD,WAEF,QAAO,OAAO,YAAY;AAG5B,aAAW,mBAAmB;AAC9B,SAAO,OAAO,WAAW"}

package/dist/context.d.mts

@@ -0,0 +1,17 @@
+import { ContextData, TraceContext } from "./types.mjs";
+
+//#region src/context.d.ts
+
+interface LogContextApi {
+  run<T>(context: ContextData, fn: () => T): T;
+  extend<T>(additionalContext: Partial<ContextData>, fn: () => T): T;
+  set(key: string, value: unknown): void;
+  get<T>(key: string): T | undefined;
+  getContext(): ContextData;
+  setTrace(trace: TraceContext): void;
+  getCurrentTrace(): TraceContext | undefined;
+  generateId(): string;
+}
+//#endregion
+export { type ContextData, LogContextApi, type TraceContext };
+//# sourceMappingURL=context.d.mts.map

package/dist/context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.mts","names":[],"sources":["../src/context.ts"],"sourcesContent":[],"mappings":";;;;AAmBuB,UAPN,aAAA,CAOM;EAAC,GAAA,CAAA,CAAA,CAAA,CAAA,OAAA,EAPM,WAON,EAAA,EAAA,EAAA,GAAA,GANmC,CAMnC,CAAA,EANuC,CAMvC;EACqB,MAAA,CAAA,CAAA,CAAA,CAAA,iBAAA,EALtB,OAKsB,CAPmB,WAAA,CAOnB,EAAA,EAAA,EAAA,GAAA,GAJ/B,CAI+B,CAAA,EAHxC,CAGwC;EACG,GAAA,CAAA,GAAA,EAAA,MAAA,EAAA,KAAA,EAAA,OAAA,CAAA,EAAA,IAAA;EACG,GAAA,CAAA,CAAA,CAAA,CAAA,GAAA,EAAA,MAAA,CAAA,EAH5B,CAG4B,GAAA,SAAA;gBAH3B;kBACqB;qBACG,YAAA"}

package/dist/context.mjs

@@ -1 +1 @@
-export{};
+export {  };

package/dist/context.node.d.mts

@@ -0,0 +1,48 @@
+import { ContextData, TraceContext } from "./types.mjs";
+
+//#region src/context.node.d.ts
+
+/**
+ * Node.js implementation of LogContext using AsyncLocalStorage.
+ */
+declare class LogContext {
+  private static instance;
+  private storage;
+  constructor();
+  static getInstance(): LogContext;
+  /**
+   * Run a function with a new context
+   */
+  run<T>(context: ContextData, fn: () => T): T;
+  /**
+   * Run a function with an extended context (merges with current)
+   */
+  extend<T>(additionalContext: Partial<ContextData>, fn: () => T): T;
+  /**
+   * Set context data for the current execution context
+   */
+  set(key: string, value: unknown): void;
+  /**
+   * Get a specific context value
+   */
+  get<T>(key: string): T | undefined;
+  /**
+   * Get all context data
+   */
+  getContext(): ContextData;
+  /**
+   * Set trace context
+   */
+  setTrace(trace: TraceContext): void;
+  /**
+   * Get current trace context
+   */
+  getCurrentTrace(): TraceContext | undefined;
+  /**
+   * Generate a unique ID for requests/operations
+   */
+  generateId(): string;
+}
+//#endregion
+export { LogContext };
+//# sourceMappingURL=context.node.d.mts.map

package/dist/context.node.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.node.d.mts","names":[],"sources":["../src/context.node.ts"],"sourcesContent":[],"mappings":";;;;;;AAWA;AAQwB,cARX,UAAA,CAQW;EAUN,eAAA,QAAA;EAAuB,QAAA,OAAA;EAAI,WAAA,CAAA;EAWN,OAAA,WAAA,CAAA,CAAA,EArBf,UAqBe;EAAR;;;EAsBR,GAAA,CAAA,CAAA,CAAA,CAAA,OAAA,EAjCL,WAiCK,EAAA,EAAA,EAAA,GAAA,GAjCkB,CAiClB,CAAA,EAjCsB,CAiCtB;EAQP;;;EAkBiB,MAAA,CAAA,CAAA,CAAA,CAAA,iBAAA,EAhDF,OAgDE,CAhDM,WAgDN,CAAA,EAAA,EAAA,EAAA,GAAA,GAhD8B,CAgD9B,CAAA,EAhDkC,CAgDlC;;;;;;;;uBA1BV;;;;gBAQP;;;;kBAQE;;;;qBAUG"}

package/dist/context.node.mjs

@@ -1 +1,79 @@
-import{AsyncLocalStorage as e}from"node:async_hooks";var t=class t{static instance;storage;constructor(){this.storage=new e}static getInstance(){return t.instance||=new t,t.instance}run(e,t){let n={context:{...e},trace:this.getCurrentTrace()};return this.storage.run(n,t)}extend(e,t){let n={...this.getContext(),...e};return this.run(n,t)}set(e,t){let n=this.storage.getStore();n&&(n.context[e]=t)}get(e){return this.storage.getStore()?.context?.[e]}getContext(){return this.storage.getStore()?.context||{}}setTrace(e){let t=this.storage.getStore();t&&(t.trace=e)}getCurrentTrace(){return this.storage.getStore()?.trace}generateId(){return crypto.randomUUID()}};export{t as LogContext};
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/context.node.ts
+/**
+* Node.js implementation of LogContext using AsyncLocalStorage.
+*/
+var LogContext = class LogContext {
+	static instance;
+	storage;
+	constructor() {
+		this.storage = new AsyncLocalStorage();
+	}
+	static getInstance() {
+		if (!LogContext.instance) LogContext.instance = new LogContext();
+		return LogContext.instance;
+	}
+	/**
+	* Run a function with a new context
+	*/
+	run(context, fn) {
+		const contextData = {
+			context: { ...context },
+			trace: this.getCurrentTrace()
+		};
+		return this.storage.run(contextData, fn);
+	}
+	/**
+	* Run a function with an extended context (merges with current)
+	*/
+	extend(additionalContext, fn) {
+		const mergedContext = {
+			...this.getContext(),
+			...additionalContext
+		};
+		return this.run(mergedContext, fn);
+	}
+	/**
+	* Set context data for the current execution context
+	*/
+	set(key, value) {
+		const current = this.storage.getStore();
+		if (current) current.context[key] = value;
+	}
+	/**
+	* Get a specific context value
+	*/
+	get(key) {
+		return this.storage.getStore()?.context?.[key];
+	}
+	/**
+	* Get all context data
+	*/
+	getContext() {
+		return this.storage.getStore()?.context || {};
+	}
+	/**
+	* Set trace context
+	*/
+	setTrace(trace) {
+		const current = this.storage.getStore();
+		if (current) current.trace = trace;
+	}
+	/**
+	* Get current trace context
+	*/
+	getCurrentTrace() {
+		return this.storage.getStore()?.trace;
+	}
+	/**
+	* Generate a unique ID for requests/operations
+	*/
+	generateId() {
+		return crypto.randomUUID();
+	}
+};
+
+//#endregion
+export { LogContext };
+//# sourceMappingURL=context.node.mjs.map

package/dist/context.node.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.node.mjs","names":["contextData: LogContextData","mergedContext: ContextData"],"sources":["../src/context.node.ts"],"sourcesContent":["import { AsyncLocalStorage } from 'node:async_hooks';\nimport type { ContextData, TraceContext } from './types';\n\ninterface LogContextData {\n  context: ContextData;\n  trace?: TraceContext;\n}\n\n/**\n * Node.js implementation of LogContext using AsyncLocalStorage.\n */\nexport class LogContext {\n  private static instance: LogContext;\n  private storage: AsyncLocalStorage<LogContextData>;\n\n  constructor() {\n    this.storage = new AsyncLocalStorage<LogContextData>();\n  }\n\n  static getInstance(): LogContext {\n    if (!LogContext.instance) {\n      LogContext.instance = new LogContext();\n    }\n    return LogContext.instance;\n  }\n\n  /**\n   * Run a function with a new context\n   */\n  run<T>(context: ContextData, fn: () => T): T {\n    const contextData: LogContextData = {\n      context: { ...context },\n      trace: this.getCurrentTrace(),\n    };\n    return this.storage.run(contextData, fn) as T;\n  }\n\n  /**\n   * Run a function with an extended context (merges with current)\n   */\n  extend<T>(additionalContext: Partial<ContextData>, fn: () => T): T {\n    const currentContext = this.getContext();\n    const mergedContext: ContextData = {\n      ...currentContext,\n      ...additionalContext,\n    };\n    return this.run(mergedContext, fn);\n  }\n\n  /**\n   * Set context data for the current execution context\n   */\n  set(key: string, value: unknown): void {\n    const current = this.storage.getStore();\n    if (current) {\n      current.context[key] = value;\n    }\n  }\n\n  /**\n   * Get a specific context value\n   */\n  get<T>(key: string): T | undefined {\n    const current = this.storage.getStore();\n    return current?.context?.[key] as T | undefined;\n  }\n\n  /**\n   * Get all context data\n   */\n  getContext(): ContextData {\n    const current = this.storage.getStore();\n    return current?.context || {};\n  }\n\n  /**\n   * Set trace context\n   */\n  setTrace(trace: TraceContext): void {\n    const current = this.storage.getStore();\n    if (current) {\n      current.trace = trace;\n    }\n  }\n\n  /**\n   * Get current trace context\n   */\n  getCurrentTrace(): TraceContext | undefined {\n    const current = this.storage.getStore();\n    return current?.trace;\n  }\n\n  /**\n   * Generate a unique ID for requests/operations\n   */\n  generateId(): string {\n    return crypto.randomUUID();\n  }\n}\n"],"mappings":";;;;;;AAWA,IAAa,aAAb,MAAa,WAAW;CACtB,OAAe;CACf,AAAQ;CAER,cAAc;AACZ,OAAK,UAAU,IAAI,mBAAmC;;CAGxD,OAAO,cAA0B;AAC/B,MAAI,CAAC,WAAW,SACd,YAAW,WAAW,IAAI,YAAY;AAExC,SAAO,WAAW;;;;;CAMpB,IAAO,SAAsB,IAAgB;EAC3C,MAAMA,cAA8B;GAClC,SAAS,EAAE,GAAG,SAAS;GACvB,OAAO,KAAK,iBAAiB;GAC9B;AACD,SAAO,KAAK,QAAQ,IAAI,aAAa,GAAG;;;;;CAM1C,OAAU,mBAAyC,IAAgB;EAEjE,MAAMC,gBAA6B;GACjC,GAFqB,KAAK,YAAY;GAGtC,GAAG;GACJ;AACD,SAAO,KAAK,IAAI,eAAe,GAAG;;;;;CAMpC,IAAI,KAAa,OAAsB;EACrC,MAAM,UAAU,KAAK,QAAQ,UAAU;AACvC,MAAI,QACF,SAAQ,QAAQ,OAAO;;;;;CAO3B,IAAO,KAA4B;AAEjC,SADgB,KAAK,QAAQ,UAAU,EACvB,UAAU;;;;;CAM5B,aAA0B;AAExB,SADgB,KAAK,QAAQ,UAAU,EACvB,WAAW,EAAE;;;;;CAM/B,SAAS,OAA2B;EAClC,MAAM,UAAU,KAAK,QAAQ,UAAU;AACvC,MAAI,QACF,SAAQ,QAAQ;;;;;CAOpB,kBAA4C;AAE1C,SADgB,KAAK,QAAQ,UAAU,EACvB;;;;;CAMlB,aAAqB;AACnB,SAAO,OAAO,YAAY"}

package/dist/elysia-plugin.d.mts

@@ -0,0 +1,64 @@
+import { ContextData } from "./types.mjs";
+import { Logger } from "./logger.node.mjs";
+import * as elysia0 from "elysia";
+import { Elysia } from "elysia";
+
+//#region src/elysia-plugin.d.ts
+interface ElysiaLoggerConfig {
+  logger?: Logger;
+  logRequests?: boolean;
+  logResponses?: boolean;
+  excludePaths?: string[];
+}
+/**
+ * Simple ElysiaJS Logger Plugin
+ * Provides automatic request logging and tracing
+ */
+declare function elysiaLogger<T extends Elysia>(config?: ElysiaLoggerConfig): (app: T) => Elysia<"", {
+  decorator: {};
+  store: {};
+  derive: {};
+  resolve: {};
+}, {
+  typebox: {};
+  error: {};
+}, {
+  schema: {};
+  standaloneSchema: {};
+  macro: {};
+  macroFn: {};
+  parser: {};
+  response: {};
+}, {}, {
+  derive: {};
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: {};
+}, {
+  derive: ({
+    readonly logger: Logger;
+    readonly requestContext?: undefined;
+    readonly startTime?: undefined;
+  } | {
+    readonly logger: Logger;
+    readonly requestContext: ContextData;
+    readonly startTime: number;
+  }) & {
+    readonly logInfo: (message: string, metadata?: Record<string, any>) => void;
+    readonly logError: (message: string, error?: Error, metadata?: Record<string, any>) => void;
+    readonly traceOperation: <T_1>(operationName: string, operation: () => T_1 | Promise<T_1>) => Promise<T_1>;
+  };
+  resolve: {};
+  schema: {};
+  standaloneSchema: {};
+  response: elysia0.ExtractErrorFromHandle<{
+    readonly logInfo: (message: string, metadata?: Record<string, any>) => void;
+    readonly logError: (message: string, error?: Error, metadata?: Record<string, any>) => void;
+    readonly traceOperation: <T_1>(operationName: string, operation: () => T_1 | Promise<T_1>) => Promise<T_1>;
+  }>;
+}>;
+declare const createElysiaLogger: typeof elysiaLogger;
+//#endregion
+export { ElysiaLoggerConfig, createElysiaLogger, elysiaLogger };
+//# sourceMappingURL=elysia-plugin.d.mts.map

package/dist/elysia-plugin.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elysia-plugin.d.mts","names":[],"sources":["../src/elysia-plugin.ts"],"sourcesContent":[],"mappings":";;;;;;UAKiB,kBAAA;WACN;;EADM,YAAA,CAAA,EAAA,OAAkB;EAWnB,YAAA,CAAA,EAAY,MAAA,EAAA;;;;;;iBAAZ,uBAAuB,iBAC7B,2BAYc,MAAC;EA+EqB,SAAA,EAAA,CAAA,CAAA;EAK5B,KAAA,EAAA,CAAA,CAAA;EAEG,MAAA,EAAA,CAAA,CAAA;EAMM,OAAA,EAAA,CAAA,CAAA;CAAY,EAAA;EAAR,OAAA,EAAA,CAAA,CAAA;EACZ,KAAA,EAAA,CAAA,CAAA;CAAR,EAAA;EAdmC,MAAA,EAAA,CAAA,CAAA;EAK5B,gBAAA,EAAA,CAAA,CAAA;EAEG,KAAA,EAAA,CAAA,CAAA;EAMM,OAAA,EAAA,CAAA,CAAA;EAAY,MAAA,EAAA,CAAA,CAAA;EAAR,QAAA,EAAA,CAAA,CAAA;CACZ,EAAA,CAAA,CAAA,EAAA;EAAR,MAAA,EAAA,CAAA,CAAA;EAAO,OAAA,EAAA,CAAA,CAAA;EA7FO,MAAA,EAAA,CAAA,CAAA;EAAA,gBAAA,EAAA,CAAA,CAAA;EA4GZ,QAAA,EAAA,CAAA,CAAA;;;;;;;;;;;mDA7BiC;iDAK5B,kBAEG;2EAMM,MAAI,QAAQ,SAC5B,QAAQ;;;;;YAAD,OAAA,CAAA;mDAd4B;iDAK5B,kBAEG;2EAMM,MAAI,QAAQ,SAC5B,QAAQ;;;cAeN,2BAAkB"}

package/dist/elysia-plugin.mjs

@@ -1 +1,85 @@
-import{LogContext as e}from"./context.node.mjs";import{Logger as t}from"./logger.node.mjs";import"elysia";function n(n={}){let{logger:r=new t,logRequests:i=!0,logResponses:a=!0,excludePaths:o=[`/health`,`/metrics`]}=n,s=e.getInstance();return function(e){return e.derive(e=>{let{request:t,path:n}=e;if(o.some(e=>n.startsWith(e)))return{logger:r};let a=new URL(t.url),c={requestId:s.generateId(),method:t.method,url:t.url,path:a.pathname,userAgent:t.headers.get(`user-agent`)||void 0,timestamp:new Date().toISOString()},l=performance.now();return s.run(c,()=>{i&&r.info(`→ ${t.method} ${n}`,{method:t.method,path:n,userAgent:c.userAgent,requestId:c.requestId})}),{logger:r,requestContext:c,startTime:l}}).onAfterHandle(e=>{let{request:t,startTime:n,requestContext:r,logger:i}=e;if(!n||!r)return;let o=performance.now()-n,s=new URL(t.url).pathname;a&&i.info(`← 200 ${t.method} ${s}`,{method:t.method,path:s,duration:`${o.toFixed(2)}ms`,requestId:r.requestId})}).onError(e=>{let{request:t,error:n,code:r,startTime:i,requestContext:a,logger:o}=e;if(!i||!a)return;let s=performance.now()-i,c=new URL(t.url).pathname;o?.error(`✖ ${r} ${t.method} ${c}`,{method:t.method,path:c,error:n?.toString?.()||`Unknown error`,code:r,duration:`${s.toFixed(2)}ms`,requestId:a.requestId})}).derive(()=>({logInfo:(e,t)=>{r.info(e,t)},logError:(e,t,n)=>{r.error(e,n,t)},traceOperation:async(e,t)=>r.trace({operationType:`custom`,operationName:e,autoTiming:!0},t)}))}}const r=n;export{r as createElysiaLogger,n as elysiaLogger};
+import { LogContext } from "./context.node.mjs";
+import { Logger } from "./logger.node.mjs";
+import { Elysia } from "elysia";
+
+//#region src/elysia-plugin.ts
+/**
+* Simple ElysiaJS Logger Plugin
+* Provides automatic request logging and tracing
+*/
+function elysiaLogger(config = {}) {
+	const { logger = new Logger(), logRequests = true, logResponses = true, excludePaths = ["/health", "/metrics"] } = config;
+	const context = LogContext.getInstance();
+	return function(app) {
+		return app.derive((ctx) => {
+			const { request, path } = ctx;
+			if (excludePaths.some((excludePath) => path.startsWith(excludePath))) return { logger };
+			const url = new URL(request.url);
+			const requestContext = {
+				requestId: context.generateId(),
+				method: request.method,
+				url: request.url,
+				path: url.pathname,
+				userAgent: request.headers.get("user-agent") || void 0,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			const startTime = performance.now();
+			context.run(requestContext, () => {
+				if (logRequests) logger.info(`→ ${request.method} ${path}`, {
+					method: request.method,
+					path,
+					userAgent: requestContext.userAgent,
+					requestId: requestContext.requestId
+				});
+			});
+			return {
+				logger,
+				requestContext,
+				startTime
+			};
+		}).onAfterHandle((ctx) => {
+			const { request, startTime, requestContext, logger: logger$1 } = ctx;
+			if (!startTime || !requestContext) return;
+			const duration = performance.now() - startTime;
+			const path = new URL(request.url).pathname;
+			if (logResponses) logger$1.info(`← 200 ${request.method} ${path}`, {
+				method: request.method,
+				path,
+				duration: `${duration.toFixed(2)}ms`,
+				requestId: requestContext.requestId
+			});
+		}).onError((ctx) => {
+			const { request, error, code, startTime, requestContext, logger: logger$1 } = ctx;
+			if (!startTime || !requestContext) return;
+			const duration = performance.now() - startTime;
+			const path = new URL(request.url).pathname;
+			logger$1?.error(`✖ ${code} ${request.method} ${path}`, {
+				method: request.method,
+				path,
+				error: error?.toString?.() || "Unknown error",
+				code,
+				duration: `${duration.toFixed(2)}ms`,
+				requestId: requestContext.requestId
+			});
+		}).derive(() => ({
+			logInfo: (message, metadata) => {
+				logger.info(message, metadata);
+			},
+			logError: (message, error, metadata) => {
+				logger.error(message, metadata, error);
+			},
+			traceOperation: async (operationName, operation) => {
+				return logger.trace({
+					operationType: "custom",
+					operationName,
+					autoTiming: true
+				}, operation);
+			}
+		}));
+	};
+}
+const createElysiaLogger = elysiaLogger;
+
+//#endregion
+export { createElysiaLogger, elysiaLogger };
+//# sourceMappingURL=elysia-plugin.mjs.map

package/dist/elysia-plugin.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"elysia-plugin.mjs","names":["requestContext: ContextData"],"sources":["../src/elysia-plugin.ts"],"sourcesContent":["import { Logger } from './logger.node';\nimport { LogContext } from './context.node';\nimport type { ContextData } from './types';\nimport { Elysia } from 'elysia';\n\nexport interface ElysiaLoggerConfig {\n  logger?: Logger;\n  logRequests?: boolean;\n  logResponses?: boolean;\n  excludePaths?: string[];\n}\n\n/**\n * Simple ElysiaJS Logger Plugin\n * Provides automatic request logging and tracing\n */\nexport function elysiaLogger<T extends Elysia>(\n  config: ElysiaLoggerConfig = {}\n) {\n  const {\n    logger = new Logger(),\n    logRequests = true,\n    logResponses = true,\n    excludePaths = ['/health', '/metrics'],\n  } = config;\n\n  const context = LogContext.getInstance();\n\n  // For type compatibility, we use a factory function\n  return function (app: T) {\n    return app\n      .derive((ctx) => {\n        const { request, path } = ctx;\n\n        // Skip excluded paths\n        if (excludePaths.some((excludePath) => path.startsWith(excludePath))) {\n          return { logger };\n        }\n\n        // Create request context\n        const url = new URL(request.url);\n        const requestContext: ContextData = {\n          requestId: context.generateId(),\n          method: request.method,\n          url: request.url,\n          path: url.pathname,\n          userAgent: request.headers.get('user-agent') || undefined,\n          timestamp: new Date().toISOString(),\n        };\n\n        const startTime = performance.now();\n\n        // Run in context\n        context.run(requestContext, () => {\n          // Log request\n          if (logRequests) {\n            logger.info(`→ ${request.method} ${path}`, {\n              method: request.method,\n              path,\n              userAgent: requestContext.userAgent,\n              requestId: requestContext.requestId,\n            });\n          }\n        });\n\n        return {\n          logger,\n          requestContext,\n          startTime,\n        };\n      })\n      .onAfterHandle((ctx) => {\n        const { request, startTime, requestContext, logger } = ctx;\n\n        if (!startTime || !requestContext) return;\n\n        const duration = performance.now() - startTime;\n        const path = new URL(request.url).pathname;\n\n        if (logResponses) {\n          logger.info(`← 200 ${request.method} ${path}`, {\n            method: request.method,\n            path,\n            duration: `${duration.toFixed(2)}ms`,\n            requestId: requestContext.requestId,\n          });\n        }\n      })\n      .onError((ctx) => {\n        const { request, error, code, startTime, requestContext, logger } = ctx;\n\n        if (!startTime || !requestContext) return;\n\n        const duration = performance.now() - startTime;\n        const path = new URL(request.url).pathname;\n\n        logger?.error(`✖ ${code} ${request.method} ${path}`, {\n          method: request.method,\n          path,\n          error: error?.toString?.() || 'Unknown error',\n          code,\n          duration: `${duration.toFixed(2)}ms`,\n          requestId: requestContext.requestId,\n        });\n      })\n      .derive(() => ({\n        // Helper functions available in route handlers\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        logInfo: (message: string, metadata?: Record<string, any>) => {\n          logger.info(message, metadata);\n        },\n        logError: (\n          message: string,\n          error?: Error,\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          metadata?: Record<string, any>\n        ) => {\n          logger.error(message, metadata, error);\n        },\n        traceOperation: async <T>(\n          operationName: string,\n          operation: () => T | Promise<T>\n        ): Promise<T> => {\n          return logger.trace(\n            {\n              operationType: 'custom',\n              operationName,\n              autoTiming: true,\n            },\n            operation\n          );\n        },\n      }));\n  };\n}\n\n// Export convenience functions\nexport const createElysiaLogger = elysiaLogger;\n"],"mappings":";;;;;;;;;AAgBA,SAAgB,aACd,SAA6B,EAAE,EAC/B;CACA,MAAM,EACJ,SAAS,IAAI,QAAQ,EACrB,cAAc,MACd,eAAe,MACf,eAAe,CAAC,WAAW,WAAW,KACpC;CAEJ,MAAM,UAAU,WAAW,aAAa;AAGxC,QAAO,SAAU,KAAQ;AACvB,SAAO,IACJ,QAAQ,QAAQ;GACf,MAAM,EAAE,SAAS,SAAS;AAG1B,OAAI,aAAa,MAAM,gBAAgB,KAAK,WAAW,YAAY,CAAC,CAClE,QAAO,EAAE,QAAQ;GAInB,MAAM,MAAM,IAAI,IAAI,QAAQ,IAAI;GAChC,MAAMA,iBAA8B;IAClC,WAAW,QAAQ,YAAY;IAC/B,QAAQ,QAAQ;IAChB,KAAK,QAAQ;IACb,MAAM,IAAI;IACV,WAAW,QAAQ,QAAQ,IAAI,aAAa,IAAI;IAChD,4BAAW,IAAI,MAAM,EAAC,aAAa;IACpC;GAED,MAAM,YAAY,YAAY,KAAK;AAGnC,WAAQ,IAAI,sBAAsB;AAEhC,QAAI,YACF,QAAO,KAAK,KAAK,QAAQ,OAAO,GAAG,QAAQ;KACzC,QAAQ,QAAQ;KAChB;KACA,WAAW,eAAe;KAC1B,WAAW,eAAe;KAC3B,CAAC;KAEJ;AAEF,UAAO;IACL;IACA;IACA;IACD;IACD,CACD,eAAe,QAAQ;GACtB,MAAM,EAAE,SAAS,WAAW,gBAAgB,qBAAW;AAEvD,OAAI,CAAC,aAAa,CAAC,eAAgB;GAEnC,MAAM,WAAW,YAAY,KAAK,GAAG;GACrC,MAAM,OAAO,IAAI,IAAI,QAAQ,IAAI,CAAC;AAElC,OAAI,aACF,UAAO,KAAK,SAAS,QAAQ,OAAO,GAAG,QAAQ;IAC7C,QAAQ,QAAQ;IAChB;IACA,UAAU,GAAG,SAAS,QAAQ,EAAE,CAAC;IACjC,WAAW,eAAe;IAC3B,CAAC;IAEJ,CACD,SAAS,QAAQ;GAChB,MAAM,EAAE,SAAS,OAAO,MAAM,WAAW,gBAAgB,qBAAW;AAEpE,OAAI,CAAC,aAAa,CAAC,eAAgB;GAEnC,MAAM,WAAW,YAAY,KAAK,GAAG;GACrC,MAAM,OAAO,IAAI,IAAI,QAAQ,IAAI,CAAC;AAElC,aAAQ,MAAM,KAAK,KAAK,GAAG,QAAQ,OAAO,GAAG,QAAQ;IACnD,QAAQ,QAAQ;IAChB;IACA,OAAO,OAAO,YAAY,IAAI;IAC9B;IACA,UAAU,GAAG,SAAS,QAAQ,EAAE,CAAC;IACjC,WAAW,eAAe;IAC3B,CAAC;IACF,CACD,cAAc;GAGb,UAAU,SAAiB,aAAmC;AAC5D,WAAO,KAAK,SAAS,SAAS;;GAEhC,WACE,SACA,OAEA,aACG;AACH,WAAO,MAAM,SAAS,UAAU,MAAM;;GAExC,gBAAgB,OACd,eACA,cACe;AACf,WAAO,OAAO,MACZ;KACE,eAAe;KACf;KACA,YAAY;KACb,EACD,UACD;;GAEJ,EAAE;;;AAKT,MAAa,qBAAqB"}

package/dist/formatters.d.mts

@@ -0,0 +1,29 @@
+import { Formatter, LogEntry } from "./types.mjs";
+
+//#region src/formatters.d.ts
+declare class DevFormatter implements Formatter {
+  private enableColors;
+  constructor(enableColors?: boolean);
+  format(entry: LogEntry): string;
+  private formatTimestamp;
+  private formatTraceInfo;
+  private formatDuration;
+  private formatContext;
+  private formatMetadata;
+  private formatError;
+  private formatObject;
+  private formatValue;
+  private colorize;
+}
+declare class ProductionFormatter implements Formatter {
+  format(entry: LogEntry): string;
+}
+declare class CustomFormatter implements Formatter {
+  private template;
+  private dateFormat;
+  constructor(template?: string, dateFormat?: (date: Date) => string);
+  format(entry: LogEntry): string;
+}
+//#endregion
+export { CustomFormatter, DevFormatter, ProductionFormatter };
+//# sourceMappingURL=formatters.d.mts.map

package/dist/formatters.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatters.d.mts","names":[],"sources":["../src/formatters.ts"],"sourcesContent":[],"mappings":";;;cAkCa,YAAA,YAAwB;;EAAxB,WAAA,CAAA,YAOG,CAPU,EAOV,OAAA;EAkJH,MAAA,CAAA,KAAA,EAlJG,QAkJiB,CAAA,EAAA,MAAA;EAkDpB,QAAA,eAAgB;EAML,QAAA,eAAA;EAMR,QAAA,cAAA;EAZwB,QAAA,aAAA;EAAS,QAAA,cAAA;;;;;;cAlDpC,mBAAA,YAA+B;gBAC5B;;cAiDH,eAAA,YAA2B;;;qDAMhB;gBAMR"}