functype-log 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Jordan
+
+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,172 @@
+# functype-log
+
+IO-native logging for the [functype](https://github.com/jordanburke/functype) ecosystem. Wraps [LogLayer](https://loglayer.dev/) with functype's `Tag`/`Layer` dependency injection system.
+
+Every log method returns `IO<never, never, void>` — logging is lazy, composable, and testable.
+
+## Install
+
+```bash
+pnpm add functype-log functype
+```
+
+## Quick Start
+
+```typescript
+import { IO } from "functype"
+import { Logger, LoggerLive } from "functype-log"
+
+const program = IO.gen(function* () {
+  const log = yield* IO.service(Logger)
+  yield* log.info("Starting", { version: "1.0.0" })
+  const result = yield* doWork()
+  yield* log.info("Done", { result })
+  return result
+})
+
+// Run with console logging
+await program.provideLayer(LoggerLive.console()).runOrThrow()
+```
+
+## Layers
+
+### Console (dev)
+
+```typescript
+await program.provideLayer(LoggerLive.console()).runOrThrow()
+await program.provideLayer(LoggerLive.console({ prefix: "[APP]" })).runOrThrow()
+```
+
+### Silent (testing/suppression)
+
+```typescript
+await program.provideLayer(LoggerLive.silent()).runOrThrow()
+```
+
+### From LogLayer (production)
+
+Use any of LogLayer's 40+ transports — pino, winston, datadog, bunyan, OpenTelemetry, etc.
+
+```typescript
+import { LogLayer } from "loglayer"
+import { PinoTransport } from "@loglayer/transport-pino"
+import pino from "pino"
+
+const pinoLog = new LogLayer({
+  transport: new PinoTransport({ logger: pino() }),
+})
+
+await program.provideLayer(LoggerLive.fromLogLayer(pinoLog)).runOrThrow()
+```
+
+### OpenTelemetry
+
+```typescript
+import { openTelemetryPlugin } from "@loglayer/plugin-opentelemetry"
+
+const otelLog = new LogLayer({
+  transport: new PinoTransport({ logger: pino() }),
+  plugins: [openTelemetryPlugin()],
+})
+
+await program.provideLayer(LoggerLive.fromLogLayer(otelLog)).runOrThrow()
+```
+
+## Logger API
+
+```typescript
+const log = yield * IO.service(Logger)
+
+// Log levels
+yield * log.trace("verbose detail")
+yield * log.debug("debug info")
+yield * log.info("informational")
+yield * log.warn("warning")
+yield * log.error("error occurred")
+yield * log.fatal("fatal error")
+
+// Structured metadata
+yield * log.info("user action", { userId: "123", action: "login" })
+
+// Error context
+yield * log.withError(err).error("operation failed")
+
+// Persistent context
+const reqLog = log.withContext({ requestId: "req-1" })
+yield * reqLog.info("first") // includes requestId
+yield * reqLog.info("second") // includes requestId
+
+// Child logger
+const child = log.child({ handler: "users" })
+```
+
+## Middleware
+
+### withLogging
+
+Wraps any IO with start/complete logging at debug level:
+
+```typescript
+import { withLogging } from "functype-log"
+
+const fetchUsers = Http.get("/api/users", { validate: UserSchema })
+const logged = withLogging("fetchUsers", fetchUsers)
+// Logs: "fetchUsers: starting" then "fetchUsers: completed"
+```
+
+### tapLog
+
+Logs after an effect completes:
+
+```typescript
+import { tapLog } from "functype-log"
+
+const result = await tapLog<number[]>(
+  "info",
+  (arr) => `fetched ${arr.length} items`,
+)(IO.succeed([1, 2, 3]))
+  .provideService(Logger, logger)
+  .runOrThrow()
+```
+
+## Testing
+
+`createTestLogger` captures log entries in memory for assertions:
+
+```typescript
+import { createTestLogger } from "functype-log"
+
+const { logger, entries, hasEntry, clear } = createTestLogger()
+
+await myProgram.provideService(Logger, logger).runOrThrow()
+
+// Assert on captured entries
+expect(entries().size).toBe(2)
+expect(hasEntry("info", "Starting")).toBe(true)
+expect(hasEntry("info", /fetched \d+ items/)).toBe(true)
+
+// Entries are List<LogEntry> with full metadata
+const first = entries().head
+expect(first.level).toBe("info")
+expect(first.metadata).toEqual({ version: "1.0.0" })
+expect(first.timestamp).toBeInstanceOf(Date)
+```
+
+## Subpath Exports
+
+```typescript
+import { Logger } from "functype-log" // everything
+import { Logger } from "functype-log/logger" // types only
+import { LoggerLive } from "functype-log/layers" // layer constructors
+import { createTestLogger } from "functype-log/testing" // test utilities
+import { withLogging } from "functype-log/middleware" // middleware
+```
+
+## Requirements
+
+- functype >= 0.55.0
+- Node.js >= 18.17.0
+
+## License
+
+MIT

package/dist/ConsoleLogger-6gnkQctP.d.ts

@@ -0,0 +1,11 @@
+import { i as Logger, n as LogLevel } from "./Logger-BFum_d5a.js";
+
+//#region src/layers/ConsoleLogger.d.ts
+type ConsoleLoggerOptions = {
+  readonly level?: LogLevel;
+  readonly prefix?: string;
+};
+declare const createConsoleLogger: (options?: ConsoleLoggerOptions) => Logger;
+//#endregion
+export { createConsoleLogger as n, ConsoleLoggerOptions as t };
+//# sourceMappingURL=ConsoleLogger-6gnkQctP.d.ts.map

package/dist/LogLayerAdapter-CtytCNjQ.d.ts

@@ -0,0 +1,8 @@
+import { i as Logger } from "./Logger-BFum_d5a.js";
+import { ILogLayer } from "loglayer";
+
+//#region src/adapter/LogLayerAdapter.d.ts
+declare const logLayerAdapter: (logLayer: ILogLayer, baseError?: Error) => Logger;
+//#endregion
+export { logLayerAdapter as t };
+//# sourceMappingURL=LogLayerAdapter-CtytCNjQ.d.ts.map

package/dist/LogMiddleware-Bv7EDRjF.d.ts

@@ -0,0 +1,11 @@
+import { i as Logger, n as LogLevel } from "./Logger-BFum_d5a.js";
+import { IO } from "functype";
+
+//#region src/middleware/LogMiddleware.d.ts
+/** Wrap any IO with start/complete/error logging at debug level */
+declare const withLogging: <R, E, A>(name: string, effect: IO<R, E, A>) => IO<R | Logger, E, A>;
+/** Create a tap function that logs at the specified level */
+declare const tapLog: <A>(level: LogLevel, message: string | ((a: A) => string)) => <R, E>(effect: IO<R, E, A>) => IO<R | Logger, E, A>;
+//#endregion
+export { withLogging as n, tapLog as t };
+//# sourceMappingURL=LogMiddleware-Bv7EDRjF.d.ts.map

package/dist/Logger-BFum_d5a.d.ts

@@ -0,0 +1,27 @@
+import { IO, Tag } from "functype";
+
+//#region src/logger/Logger.d.ts
+type LogLevel = "trace" | "debug" | "info" | "warn" | "error" | "fatal";
+type LogMetadata = Record<string, unknown>;
+type LogEntry = {
+  readonly level: LogLevel;
+  readonly message: string;
+  readonly metadata?: LogMetadata;
+  readonly error?: Error;
+  readonly timestamp: Date;
+};
+type Logger = {
+  readonly trace: (message: string, metadata?: LogMetadata) => IO<never, never, void>;
+  readonly debug: (message: string, metadata?: LogMetadata) => IO<never, never, void>;
+  readonly info: (message: string, metadata?: LogMetadata) => IO<never, never, void>;
+  readonly warn: (message: string, metadata?: LogMetadata) => IO<never, never, void>;
+  readonly error: (message: string, metadata?: LogMetadata) => IO<never, never, void>;
+  readonly fatal: (message: string, metadata?: LogMetadata) => IO<never, never, void>;
+  readonly withError: (error: Error) => Logger;
+  readonly withContext: (context: LogMetadata) => Logger;
+  readonly child: (context?: LogMetadata) => Logger;
+};
+declare const Logger: Tag<Logger>;
+//#endregion
+export { Logger as i, LogLevel as n, LogMetadata as r, LogEntry as t };
+//# sourceMappingURL=Logger-BFum_d5a.d.ts.map

package/dist/LoggerLayer-B-tD-_gO.d.ts

@@ -0,0 +1,14 @@
+import { i as Logger } from "./Logger-BFum_d5a.js";
+import { t as ConsoleLoggerOptions } from "./ConsoleLogger-6gnkQctP.js";
+import { Layer } from "functype";
+import { ILogLayer } from "loglayer";
+
+//#region src/layers/LoggerLayer.d.ts
+declare const LoggerLive: {
+  /** From an existing LogLayer instance — escape hatch for power users (pino, winston, datadog, etc.) */fromLogLayer: (logLayer: ILogLayer) => Layer<never, never, Logger>; /** Console logger — zero config, great for dev */
+  console: (options?: ConsoleLoggerOptions) => Layer<never, never, Logger>; /** Silent/noop logger — for testing or suppression */
+  silent: () => Layer<never, never, Logger>;
+};
+//#endregion
+export { LoggerLive as t };
+//# sourceMappingURL=LoggerLayer-B-tD-_gO.d.ts.map

package/dist/SilentLogger-BWfCzQqB.d.ts

@@ -0,0 +1,7 @@
+import { i as Logger } from "./Logger-BFum_d5a.js";
+
+//#region src/layers/SilentLogger.d.ts
+declare const silentLogger: Logger;
+//#endregion
+export { silentLogger as t };
+//# sourceMappingURL=SilentLogger-BWfCzQqB.d.ts.map

package/dist/TestLogger-4s7rQHxR.d.ts

@@ -0,0 +1,14 @@
+import { i as Logger, n as LogLevel, t as LogEntry } from "./Logger-BFum_d5a.js";
+import { List } from "functype";
+
+//#region src/testing/TestLogger.d.ts
+type TestLoggerHandle = {
+  readonly logger: Logger;
+  readonly entries: () => List<LogEntry>;
+  readonly clear: () => void;
+  readonly hasEntry: (level: LogLevel, messagePattern: string | RegExp) => boolean;
+};
+declare const createTestLogger: () => TestLoggerHandle;
+//#endregion
+export { createTestLogger as n, TestLoggerHandle as t };
+//# sourceMappingURL=TestLogger-4s7rQHxR.d.ts.map

package/dist/adapter/LogLayerAdapter.d.ts

@@ -0,0 +1,2 @@
+import { t as logLayerAdapter } from "../LogLayerAdapter-CtytCNjQ.js";
+export { logLayerAdapter };

package/dist/adapter/LogLayerAdapter.js

@@ -0,0 +1,2 @@
+import{IO as e}from"functype";const t=(t,n,r)=>(i,a)=>e.sync(()=>{let e=a?t.withMetadata(a):t;r&&(e=e.withError(r)),e[n](i)}),n=(e,r)=>({trace:t(e,`trace`,r),debug:t(e,`debug`,r),info:t(e,`info`,r),warn:t(e,`warn`,r),error:t(e,`error`,r),fatal:t(e,`fatal`,r),withError:t=>n(e,t),withContext:t=>n(e.withContext(t),r),child:t=>{let r=e.child();return n(t?r.withContext(t):r)}});export{n as logLayerAdapter};
+//# sourceMappingURL=LogLayerAdapter.js.map

package/dist/adapter/LogLayerAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogLayerAdapter.js","names":[],"sources":["../../src/adapter/LogLayerAdapter.ts"],"sourcesContent":["import { IO } from \"functype\"\nimport type { ILogLayer } from \"loglayer\"\n\nimport type { Logger, LogLevel, LogMetadata } from \"../logger/Logger\"\n\nconst makeMethod =\n  (logLayer: ILogLayer, level: LogLevel, baseError?: Error) =>\n  (message: string, metadata?: LogMetadata): IO<never, never, void> =>\n    IO.sync(() => {\n      let entry = metadata ? logLayer.withMetadata(metadata) : logLayer\n      if (baseError) {\n        entry = entry.withError(baseError)\n      }\n      entry[level](message)\n    })\n\nexport const logLayerAdapter = (logLayer: ILogLayer, baseError?: Error): Logger => ({\n  trace: makeMethod(logLayer, \"trace\", baseError),\n  debug: makeMethod(logLayer, \"debug\", baseError),\n  info: makeMethod(logLayer, \"info\", baseError),\n  warn: makeMethod(logLayer, \"warn\", baseError),\n  error: makeMethod(logLayer, \"error\", baseError),\n  fatal: makeMethod(logLayer, \"fatal\", baseError),\n  withError: (err: Error) => logLayerAdapter(logLayer, err),\n  withContext: (ctx: LogMetadata) => logLayerAdapter(logLayer.withContext(ctx), baseError),\n  child: (ctx?: LogMetadata) => {\n    const childLog = logLayer.child()\n    return ctx ? logLayerAdapter(childLog.withContext(ctx)) : logLayerAdapter(childLog)\n  },\n})\n"],"mappings":"8BAKA,MAAM,GACH,EAAqB,EAAiB,KACtC,EAAiB,IAChB,EAAG,SAAW,CACZ,IAAI,EAAQ,EAAW,EAAS,aAAa,EAAS,CAAG,EACrD,IACF,EAAQ,EAAM,UAAU,EAAU,EAEpC,EAAM,GAAO,EAAQ,EACrB,CAEO,GAAmB,EAAqB,KAA+B,CAClF,MAAO,EAAW,EAAU,QAAS,EAAU,CAC/C,MAAO,EAAW,EAAU,QAAS,EAAU,CAC/C,KAAM,EAAW,EAAU,OAAQ,EAAU,CAC7C,KAAM,EAAW,EAAU,OAAQ,EAAU,CAC7C,MAAO,EAAW,EAAU,QAAS,EAAU,CAC/C,MAAO,EAAW,EAAU,QAAS,EAAU,CAC/C,UAAY,GAAe,EAAgB,EAAU,EAAI,CACzD,YAAc,GAAqB,EAAgB,EAAS,YAAY,EAAI,CAAE,EAAU,CACxF,MAAQ,GAAsB,CAC5B,IAAM,EAAW,EAAS,OAAO,CACjC,OAAa,EAAN,EAAsB,EAAS,YAAY,EAAI,CAAoB,EAAS,EAEtF"}

package/dist/adapter/index.d.ts

@@ -0,0 +1,2 @@
+import { t as logLayerAdapter } from "../LogLayerAdapter-CtytCNjQ.js";
+export { logLayerAdapter };

package/dist/adapter/index.js

@@ -0,0 +1 @@
+import{logLayerAdapter as e}from"./LogLayerAdapter.js";export{e as logLayerAdapter};

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { i as Logger, n as LogLevel, r as LogMetadata, t as LogEntry } from "./Logger-BFum_d5a.js";
+import { t as logLayerAdapter } from "./LogLayerAdapter-CtytCNjQ.js";
+import { n as createConsoleLogger, t as ConsoleLoggerOptions } from "./ConsoleLogger-6gnkQctP.js";
+import { t as LoggerLive } from "./LoggerLayer-B-tD-_gO.js";
+import { t as silentLogger } from "./SilentLogger-BWfCzQqB.js";
+import { n as createTestLogger, t as TestLoggerHandle } from "./TestLogger-4s7rQHxR.js";
+import { n as withLogging, t as tapLog } from "./LogMiddleware-Bv7EDRjF.js";
+export { type ConsoleLoggerOptions, type LogEntry, type LogLevel, type LogMetadata, Logger, LoggerLive, type TestLoggerHandle, createConsoleLogger, createTestLogger, logLayerAdapter, silentLogger, tapLog, withLogging };

package/dist/index.js

@@ -0,0 +1 @@
+import{Logger as e}from"./logger/Logger.js";import"./logger/index.js";import{logLayerAdapter as t}from"./adapter/LogLayerAdapter.js";import{createConsoleLogger as n}from"./layers/ConsoleLogger.js";import{silentLogger as r}from"./layers/SilentLogger.js";import{LoggerLive as i}from"./layers/LoggerLayer.js";import"./layers/index.js";import"./adapter/index.js";import{createTestLogger as a}from"./testing/TestLogger.js";import"./testing/index.js";import{tapLog as o,withLogging as s}from"./middleware/LogMiddleware.js";import"./middleware/index.js";export{e as Logger,i as LoggerLive,n as createConsoleLogger,a as createTestLogger,t as logLayerAdapter,r as silentLogger,o as tapLog,s as withLogging};

package/dist/layers/ConsoleLogger.d.ts

@@ -0,0 +1,2 @@
+import { n as createConsoleLogger, t as ConsoleLoggerOptions } from "../ConsoleLogger-6gnkQctP.js";
+export { ConsoleLoggerOptions, createConsoleLogger };

package/dist/layers/ConsoleLogger.js

@@ -0,0 +1,2 @@
+import{logLayerAdapter as e}from"../adapter/LogLayerAdapter.js";import{ConsoleTransport as t,LogLayer as n}from"loglayer";const r=r=>e(new n({transport:new t({logger:console}),...r?.prefix?{prefix:r.prefix}:{}}));export{r as createConsoleLogger};
+//# sourceMappingURL=ConsoleLogger.js.map

package/dist/layers/ConsoleLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConsoleLogger.js","names":[],"sources":["../../src/layers/ConsoleLogger.ts"],"sourcesContent":["import { ConsoleTransport, LogLayer } from \"loglayer\"\n\nimport { logLayerAdapter } from \"../adapter/LogLayerAdapter\"\nimport type { Logger, LogLevel } from \"../logger/Logger\"\n\nexport type ConsoleLoggerOptions = {\n  readonly level?: LogLevel\n  readonly prefix?: string\n}\n\nexport const createConsoleLogger = (options?: ConsoleLoggerOptions): Logger => {\n  const logLayer = new LogLayer({\n    transport: new ConsoleTransport({ logger: console }),\n    ...(options?.prefix ? { prefix: options.prefix } : {}),\n  })\n\n  return logLayerAdapter(logLayer)\n}\n"],"mappings":"0HAUA,MAAa,EAAuB,GAM3B,EALU,IAAI,EAAS,CAC5B,UAAW,IAAI,EAAiB,CAAE,OAAQ,QAAS,CAAC,CACpD,GAAI,GAAS,OAAS,CAAE,OAAQ,EAAQ,OAAQ,CAAG,EAAE,CACtD,CAAC,CAE8B"}

package/dist/layers/LoggerLayer.d.ts

@@ -0,0 +1,2 @@
+import { t as LoggerLive } from "../LoggerLayer-B-tD-_gO.js";
+export { LoggerLive };

package/dist/layers/LoggerLayer.js

@@ -0,0 +1,2 @@
+import{Logger as e}from"../logger/Logger.js";import{logLayerAdapter as t}from"../adapter/LogLayerAdapter.js";import{createConsoleLogger as n}from"./ConsoleLogger.js";import{silentLogger as r}from"./SilentLogger.js";import{Layer as i}from"functype";const a={fromLogLayer:n=>i.succeed(e,t(n)),console:t=>i.sync(e,()=>n(t)),silent:()=>i.succeed(e,r)};export{a as LoggerLive};
+//# sourceMappingURL=LoggerLayer.js.map

package/dist/layers/LoggerLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoggerLayer.js","names":[],"sources":["../../src/layers/LoggerLayer.ts"],"sourcesContent":["import { Layer } from \"functype\"\nimport type { ILogLayer } from \"loglayer\"\n\nimport { logLayerAdapter } from \"../adapter/LogLayerAdapter\"\nimport { Logger } from \"../logger/Logger\"\nimport type { ConsoleLoggerOptions } from \"./ConsoleLogger\"\nimport { createConsoleLogger } from \"./ConsoleLogger\"\nimport { silentLogger } from \"./SilentLogger\"\n\nexport const LoggerLive = {\n  /** From an existing LogLayer instance — escape hatch for power users (pino, winston, datadog, etc.) */\n  fromLogLayer: (logLayer: ILogLayer): Layer<never, never, Logger> => Layer.succeed(Logger, logLayerAdapter(logLayer)),\n\n  /** Console logger — zero config, great for dev */\n  console: (options?: ConsoleLoggerOptions): Layer<never, never, Logger> =>\n    Layer.sync(Logger, () => createConsoleLogger(options)),\n\n  /** Silent/noop logger — for testing or suppression */\n  silent: (): Layer<never, never, Logger> => Layer.succeed(Logger, silentLogger),\n}\n"],"mappings":"wPASA,MAAa,EAAa,CAExB,aAAe,GAAqD,EAAM,QAAQ,EAAQ,EAAgB,EAAS,CAAC,CAGpH,QAAU,GACR,EAAM,KAAK,MAAc,EAAoB,EAAQ,CAAC,CAGxD,WAA2C,EAAM,QAAQ,EAAQ,EAAa,CAC/E"}

package/dist/layers/SilentLogger.d.ts

@@ -0,0 +1,2 @@
+import { t as silentLogger } from "../SilentLogger-BWfCzQqB.js";
+export { silentLogger };

package/dist/layers/SilentLogger.js

@@ -0,0 +1,2 @@
+import{IO as e}from"functype";const t=(t,n)=>e.succeed(void 0),n={trace:t,debug:t,info:t,warn:t,error:t,fatal:t,withError:()=>n,withContext:()=>n,child:()=>n};export{n as silentLogger};
+//# sourceMappingURL=SilentLogger.js.map

package/dist/layers/SilentLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SilentLogger.js","names":[],"sources":["../../src/layers/SilentLogger.ts"],"sourcesContent":["import { IO } from \"functype\"\n\nimport type { Logger, LogMetadata } from \"../logger/Logger\"\n\nconst noop = (_message: string, _metadata?: LogMetadata): IO<never, never, void> => IO.succeed(undefined as void)\n\nexport const silentLogger: Logger = {\n  trace: noop,\n  debug: noop,\n  info: noop,\n  warn: noop,\n  error: noop,\n  fatal: noop,\n  withError: () => silentLogger,\n  withContext: () => silentLogger,\n  child: () => silentLogger,\n}\n"],"mappings":"8BAIA,MAAM,GAAQ,EAAkB,IAAoD,EAAG,QAAQ,IAAA,GAAkB,CAEpG,EAAuB,CAClC,MAAO,EACP,MAAO,EACP,KAAM,EACN,KAAM,EACN,MAAO,EACP,MAAO,EACP,cAAiB,EACjB,gBAAmB,EACnB,UAAa,EACd"}

package/dist/layers/index.d.ts

@@ -0,0 +1,4 @@
+import { n as createConsoleLogger, t as ConsoleLoggerOptions } from "../ConsoleLogger-6gnkQctP.js";
+import { t as LoggerLive } from "../LoggerLayer-B-tD-_gO.js";
+import { t as silentLogger } from "../SilentLogger-BWfCzQqB.js";
+export { type ConsoleLoggerOptions, LoggerLive, createConsoleLogger, silentLogger };

package/dist/layers/index.js

@@ -0,0 +1 @@
+import{createConsoleLogger as e}from"./ConsoleLogger.js";import{silentLogger as t}from"./SilentLogger.js";import{LoggerLive as n}from"./LoggerLayer.js";export{n as LoggerLive,e as createConsoleLogger,t as silentLogger};

package/dist/logger/Logger.d.ts

@@ -0,0 +1,2 @@
+import { i as Logger, n as LogLevel, r as LogMetadata, t as LogEntry } from "../Logger-BFum_d5a.js";
+export { LogEntry, LogLevel, LogMetadata, Logger };

package/dist/logger/Logger.js

@@ -0,0 +1,2 @@
+import{Tag as e}from"functype";const t=e(`Logger`);export{t as Logger};
+//# sourceMappingURL=Logger.js.map

package/dist/logger/Logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Logger.js","names":[],"sources":["../../src/logger/Logger.ts"],"sourcesContent":["import type { IO } from \"functype\"\nimport { Tag } from \"functype\"\n\nexport type LogLevel = \"trace\" | \"debug\" | \"info\" | \"warn\" | \"error\" | \"fatal\"\n\nexport type LogMetadata = Record<string, unknown>\n\nexport type LogEntry = {\n  readonly level: LogLevel\n  readonly message: string\n  readonly metadata?: LogMetadata\n  readonly error?: Error\n  readonly timestamp: Date\n}\n\nexport type Logger = {\n  readonly trace: (message: string, metadata?: LogMetadata) => IO<never, never, void>\n  readonly debug: (message: string, metadata?: LogMetadata) => IO<never, never, void>\n  readonly info: (message: string, metadata?: LogMetadata) => IO<never, never, void>\n  readonly warn: (message: string, metadata?: LogMetadata) => IO<never, never, void>\n  readonly error: (message: string, metadata?: LogMetadata) => IO<never, never, void>\n  readonly fatal: (message: string, metadata?: LogMetadata) => IO<never, never, void>\n  readonly withError: (error: Error) => Logger\n  readonly withContext: (context: LogMetadata) => Logger\n  readonly child: (context?: LogMetadata) => Logger\n}\n\nexport const Logger = Tag<Logger>(\"Logger\")\n"],"mappings":"+BA2BA,MAAa,EAAS,EAAY,SAAS"}

package/dist/logger/index.d.ts

@@ -0,0 +1,2 @@
+import { i as Logger, n as LogLevel, r as LogMetadata, t as LogEntry } from "../Logger-BFum_d5a.js";
+export { type LogEntry, type LogLevel, type LogMetadata, Logger };

package/dist/logger/index.js

@@ -0,0 +1 @@
+import{Logger as e}from"./Logger.js";export{e as Logger};

package/dist/middleware/LogMiddleware.d.ts

@@ -0,0 +1,2 @@
+import { n as withLogging, t as tapLog } from "../LogMiddleware-Bv7EDRjF.js";
+export { tapLog, withLogging };

package/dist/middleware/LogMiddleware.js

@@ -0,0 +1,2 @@
+import{Logger as e}from"../logger/Logger.js";import{IO as t}from"functype";const n=(n,r)=>t.gen(function*(){let i=yield*t.service(e);yield*i.debug(`${n}: starting`);let a=yield*r;return yield*i.debug(`${n}: completed`),a}),r=(n,r)=>i=>t.gen(function*(){let a=yield*i,o=yield*t.service(e),s=typeof r==`string`?r:r(a);return yield*o[n](s),a});export{r as tapLog,n as withLogging};
+//# sourceMappingURL=LogMiddleware.js.map

package/dist/middleware/LogMiddleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LogMiddleware.js","names":["IOImpl","LoggerTag"],"sources":["../../src/middleware/LogMiddleware.ts"],"sourcesContent":["import type { IO } from \"functype\"\nimport { IO as IOImpl } from \"functype\"\n\nimport type { Logger, LogLevel } from \"../logger/Logger\"\nimport { Logger as LoggerTag } from \"../logger/Logger\"\n\n/** Wrap any IO with start/complete/error logging at debug level */\nexport const withLogging = <R, E, A>(name: string, effect: IO<R, E, A>): IO<R | Logger, E, A> =>\n  IOImpl.gen(function* () {\n    const log = yield* IOImpl.service(LoggerTag)\n    yield* log.debug(`${name}: starting`)\n    const result = yield* effect\n    yield* log.debug(`${name}: completed`)\n    return result\n  }) as IO<R | Logger, E, A>\n\n/** Create a tap function that logs at the specified level */\nexport const tapLog =\n  <A>(level: LogLevel, message: string | ((a: A) => string)) =>\n  <R, E>(effect: IO<R, E, A>): IO<R | Logger, E, A> =>\n    IOImpl.gen(function* () {\n      const result = yield* effect\n      const log = yield* IOImpl.service(LoggerTag)\n      const msg = typeof message === \"string\" ? message : message(result)\n      yield* log[level](msg)\n      return result\n    }) as IO<R | Logger, E, A>\n"],"mappings":"2EAOA,MAAa,GAAwB,EAAc,IACjDA,EAAO,IAAI,WAAa,CACtB,IAAM,EAAM,MAAOA,EAAO,QAAQC,EAAU,CAC5C,MAAO,EAAI,MAAM,GAAG,EAAK,YAAY,CACrC,IAAM,EAAS,MAAO,EAEtB,OADA,MAAO,EAAI,MAAM,GAAG,EAAK,aAAa,CAC/B,GACP,CAGS,GACP,EAAiB,IACd,GACLD,EAAO,IAAI,WAAa,CACtB,IAAM,EAAS,MAAO,EAChB,EAAM,MAAOA,EAAO,QAAQC,EAAU,CACtC,EAAM,OAAO,GAAY,SAAW,EAAU,EAAQ,EAAO,CAEnE,OADA,MAAO,EAAI,GAAO,EAAI,CACf,GACP"}

package/dist/middleware/index.d.ts

@@ -0,0 +1,2 @@
+import { n as withLogging, t as tapLog } from "../LogMiddleware-Bv7EDRjF.js";
+export { tapLog, withLogging };

package/dist/middleware/index.js

@@ -0,0 +1 @@
+import{tapLog as e,withLogging as t}from"./LogMiddleware.js";export{e as tapLog,t as withLogging};

package/dist/testing/TestLogger.d.ts

@@ -0,0 +1,2 @@
+import { n as createTestLogger, t as TestLoggerHandle } from "../TestLogger-4s7rQHxR.js";
+export { TestLoggerHandle, createTestLogger };

package/dist/testing/TestLogger.js

@@ -0,0 +1,2 @@
+import{IO as e,List as t}from"functype";const n=(t,r,i)=>{let a=n=>(a,o)=>e.sync(()=>{t.push({level:n,message:a,metadata:Object.keys(r).length>0||o?{...r,...o}:void 0,error:i,timestamp:new Date})});return{trace:a(`trace`),debug:a(`debug`),info:a(`info`),warn:a(`warn`),error:a(`error`),fatal:a(`fatal`),withError:e=>n(t,r,e),withContext:e=>n(t,{...r,...e},i),child:e=>n(t,{...r,...e},void 0)}},r=()=>{let e=[];return{logger:n(e,{}),entries:()=>t(e),clear:()=>{e.length=0},hasEntry:(t,n)=>e.some(e=>e.level===t&&(typeof n==`string`?e.message.includes(n):n.test(e.message)))}};export{r as createTestLogger};
+//# sourceMappingURL=TestLogger.js.map

package/dist/testing/TestLogger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestLogger.js","names":[],"sources":["../../src/testing/TestLogger.ts"],"sourcesContent":["import { IO, List } from \"functype\"\n\nimport type { LogEntry, Logger, LogLevel, LogMetadata } from \"../logger/Logger\"\n\nexport type TestLoggerHandle = {\n  readonly logger: Logger\n  readonly entries: () => List<LogEntry>\n  readonly clear: () => void\n  readonly hasEntry: (level: LogLevel, messagePattern: string | RegExp) => boolean\n}\n\nconst createLoggerFromStore = (store: LogEntry[], baseContext: LogMetadata, baseError?: Error): Logger => {\n  const makeMethod =\n    (level: LogLevel) =>\n    (message: string, metadata?: LogMetadata): IO<never, never, void> =>\n      IO.sync(() => {\n        store.push({\n          level,\n          message,\n          metadata: Object.keys(baseContext).length > 0 || metadata ? { ...baseContext, ...metadata } : undefined,\n          error: baseError,\n          timestamp: new Date(),\n        })\n      })\n\n  return {\n    trace: makeMethod(\"trace\"),\n    debug: makeMethod(\"debug\"),\n    info: makeMethod(\"info\"),\n    warn: makeMethod(\"warn\"),\n    error: makeMethod(\"error\"),\n    fatal: makeMethod(\"fatal\"),\n    withError: (err: Error) => createLoggerFromStore(store, baseContext, err),\n    withContext: (ctx: LogMetadata) => createLoggerFromStore(store, { ...baseContext, ...ctx }, baseError),\n    child: (ctx?: LogMetadata) => createLoggerFromStore(store, { ...baseContext, ...ctx }, undefined),\n  }\n}\n\nexport const createTestLogger = (): TestLoggerHandle => {\n  const store: LogEntry[] = []\n\n  return {\n    logger: createLoggerFromStore(store, {}),\n    entries: () => List(store),\n    clear: () => {\n      store.length = 0\n    },\n    hasEntry: (level: LogLevel, messagePattern: string | RegExp) =>\n      store.some(\n        (e) =>\n          e.level === level &&\n          (typeof messagePattern === \"string\" ? e.message.includes(messagePattern) : messagePattern.test(e.message)),\n      ),\n  }\n}\n"],"mappings":"wCAWA,MAAM,GAAyB,EAAmB,EAA0B,IAA8B,CACxG,IAAM,EACH,IACA,EAAiB,IAChB,EAAG,SAAW,CACZ,EAAM,KAAK,CACT,QACA,UACA,SAAU,OAAO,KAAK,EAAY,CAAC,OAAS,GAAK,EAAW,CAAE,GAAG,EAAa,GAAG,EAAU,CAAG,IAAA,GAC9F,MAAO,EACP,UAAW,IAAI,KAChB,CAAC,EACF,CAEN,MAAO,CACL,MAAO,EAAW,QAAQ,CAC1B,MAAO,EAAW,QAAQ,CAC1B,KAAM,EAAW,OAAO,CACxB,KAAM,EAAW,OAAO,CACxB,MAAO,EAAW,QAAQ,CAC1B,MAAO,EAAW,QAAQ,CAC1B,UAAY,GAAe,EAAsB,EAAO,EAAa,EAAI,CACzE,YAAc,GAAqB,EAAsB,EAAO,CAAE,GAAG,EAAa,GAAG,EAAK,CAAE,EAAU,CACtG,MAAQ,GAAsB,EAAsB,EAAO,CAAE,GAAG,EAAa,GAAG,EAAK,CAAE,IAAA,GAAU,CAClG,EAGU,MAA2C,CACtD,IAAM,EAAoB,EAAE,CAE5B,MAAO,CACL,OAAQ,EAAsB,EAAO,EAAE,CAAC,CACxC,YAAe,EAAK,EAAM,CAC1B,UAAa,CACX,EAAM,OAAS,GAEjB,UAAW,EAAiB,IAC1B,EAAM,KACH,GACC,EAAE,QAAU,IACX,OAAO,GAAmB,SAAW,EAAE,QAAQ,SAAS,EAAe,CAAG,EAAe,KAAK,EAAE,QAAQ,EAC5G,CACJ"}

package/dist/testing/index.d.ts

@@ -0,0 +1,2 @@
+import { n as createTestLogger, t as TestLoggerHandle } from "../TestLogger-4s7rQHxR.js";
+export { type TestLoggerHandle, createTestLogger };

package/dist/testing/index.js

@@ -0,0 +1 @@
+import{createTestLogger as e}from"./TestLogger.js";export{e as createTestLogger};

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "functype-log",
+  "version": "0.1.0",
+  "description": "IO-native logging for functype — wraps LogLayer with Tag/Layer DI, structured logging, and test utilities",
+  "keywords": [
+    "functype",
+    "functional",
+    "logging",
+    "loglayer",
+    "io",
+    "dependency-injection",
+    "typescript"
+  ],
+  "author": "jordan.burke@gmail.com",
+  "license": "MIT",
+  "homepage": "https://github.com/jordanburke/functype-log",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jordanburke/functype-log"
+  },
+  "peerDependencies": {
+    "functype": ">=0.55.0"
+  },
+  "dependencies": {
+    "loglayer": "^9.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.0",
+    "functype": "^0.56.0",
+    "ts-builds": "^2.6.3",
+    "tsdown": "^0.21.7"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./logger": {
+      "types": "./dist/logger/index.d.ts",
+      "import": "./dist/logger/index.js",
+      "default": "./dist/logger/index.js"
+    },
+    "./layers": {
+      "types": "./dist/layers/index.d.ts",
+      "import": "./dist/layers/index.js",
+      "default": "./dist/layers/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "import": "./dist/testing/index.js",
+      "default": "./dist/testing/index.js"
+    },
+    "./middleware": {
+      "types": "./dist/middleware/index.d.ts",
+      "import": "./dist/middleware/index.js",
+      "default": "./dist/middleware/index.js"
+    }
+  },
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "prettier": "ts-builds/prettier",
+  "engines": {
+    "node": ">=18.17.0"
+  },
+  "scripts": {
+    "validate": "ts-builds validate",
+    "format": "ts-builds format",
+    "format:check": "ts-builds format:check",
+    "lint": "ts-builds lint",
+    "lint:check": "ts-builds lint:check",
+    "typecheck": "ts-builds typecheck",
+    "test": "ts-builds test",
+    "test:watch": "ts-builds test:watch",
+    "test:coverage": "ts-builds test:coverage",
+    "build": "ts-builds build",
+    "dev": "ts-builds dev"
+  }
+}