@decohere/scribe-pino 0.0.1-dev.65 → 0.0.1-dev.67

package/commonjs/src/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 _export_star(require("./pino.adapater.js"), exports);
+_export_star(require("./pino.recipe.js"), exports);
 _export_star(require("./scribe-pino.js"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
@@ -18,4 +19,4 @@ function _export_star(from, to) {
     return from;
 }
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUtcGluby9zcmMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vcGluby5hZGFwYXRlci5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vc2NyaWJlLXBpbm8uanNcIjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O3FCQUFjO3FCQUNBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUtcGluby9zcmMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vcGluby5hZGFwYXRlci5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcGluby5yZWNpcGUuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NjcmliZS1waW5vLmpzXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztxQkFBYztxQkFDQTtxQkFDQSJ9

package/commonjs/src/pino.recipe.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "pinoRecipe", {
+    enumerable: true,
+    get: function() {
+        return pinoRecipe;
+    }
+});
+const _system = require("@decohere/nexus/system");
+const DEFAULT_ROLL_SIZE = "10m";
+const DEFAULT_ROLL_FREQUENCY = "daily";
+const DEFAULT_ROLL_KEEP = 14;
+function currentEnvironment() {
+    return process.env.NODE_ENV === _system.Environments.production ? _system.Environments.production : _system.Environments.development;
+}
+function isEnabled(when, environment) {
+    return (when ?? "development") === "always" || environment === _system.Environments.development;
+}
+function prettyTarget(options) {
+    return {
+        target: "pino-pretty",
+        options: {
+            colorize: options.colorize ?? true
+        }
+    };
+}
+function rollTarget(options) {
+    return {
+        target: "pino-roll",
+        options: {
+            file: options.file,
+            mkdir: options.mkdir ?? true,
+            size: options.size ?? DEFAULT_ROLL_SIZE,
+            frequency: options.frequency ?? DEFAULT_ROLL_FREQUENCY,
+            limit: {
+                count: options.keep ?? DEFAULT_ROLL_KEEP
+            },
+            symlink: options.symlink ?? true
+        }
+    };
+}
+function transport(plan, environment = currentEnvironment()) {
+    const targets = [];
+    if (plan.pretty && isEnabled(plan.pretty.when, environment)) {
+        targets.push(prettyTarget(plan.pretty));
+    }
+    if (plan.roll && isEnabled(plan.roll.when, environment)) {
+        targets.push(rollTarget(plan.roll));
+    }
+    if (targets.length === 0) {
+        return undefined;
+    }
+    if (targets.length === 1) {
+        return targets[0];
+    }
+    return {
+        targets
+    };
+}
+const pinoRecipe = {
+    transport,
+    currentEnvironment
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/scribe-pino.js

@@ -12,6 +12,7 @@ const _extensibility = require("@decohere/nexus/extensibility");
 const _system = require("@decohere/nexus/system");
 const _scribe = require("@decohere/scribe");
 const _pinoadapater = require("./pino.adapater.js");
+const _pinorecipe = require("./pino.recipe.js");
 function _ts_decorate(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);
@@ -27,23 +28,28 @@ class PinoExtensions {
             logLevel
         }, config);
     }
-    static withPinoPretty(factory, logLevel) {
-        return PinoExtensions.withPino(factory, {
-            transports: {
-                target: "pino-pretty",
-                options: {
-                    colorize: true
-                }
-            }
-        }, logLevel);
+    static withPinoPretty(factory, logLevelOrOptions) {
+        const pretty = parsePrettyArg(logLevelOrOptions);
+        return attachRecipe(factory, {
+            pretty,
+            logLevel: pretty.logLevel
+        });
+    }
+    static withPinoRoll(factory, options) {
+        return attachRecipe(factory, {
+            roll: options,
+            logLevel: options.logLevel
+        });
     }
     static withPinoCustom(factory, options) {
-        const { scribe, transports } = options;
+        const { scribe, transports } = options ?? {};
         return configureScribe(factory, scribe, transports);
     }
 }
 _ts_decorate([
-    (0, _extensibility.extension)(_scribe.scribe),
+    (0, _extensibility.extension)(_scribe.scribe, {
+        static: true
+    }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _scribe.scribe === "undefined" ? Object : _scribe.scribe,
@@ -53,7 +59,9 @@ _ts_decorate([
     _ts_metadata("design:returntype", void 0)
 ], PinoExtensions, "withPino", null);
 _ts_decorate([
-    (0, _extensibility.extension)(_scribe.scribe),
+    (0, _extensibility.extension)(_scribe.scribe, {
+        static: true
+    }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _scribe.scribe === "undefined" ? Object : _scribe.scribe,
@@ -62,7 +70,20 @@ _ts_decorate([
     _ts_metadata("design:returntype", void 0)
 ], PinoExtensions, "withPinoPretty", null);
 _ts_decorate([
-    (0, _extensibility.extension)(_scribe.scribe),
+    (0, _extensibility.extension)(_scribe.scribe, {
+        static: true
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _scribe.scribe === "undefined" ? Object : _scribe.scribe,
+        typeof PinoRollRecipeOptions === "undefined" ? Object : PinoRollRecipeOptions
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], PinoExtensions, "withPinoRoll", null);
+_ts_decorate([
+    (0, _extensibility.extension)(_scribe.scribe, {
+        static: true
+    }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _scribe.scribe === "undefined" ? Object : _scribe.scribe,
@@ -70,19 +91,67 @@ _ts_decorate([
     ]),
     _ts_metadata("design:returntype", void 0)
 ], PinoExtensions, "withPinoCustom", null);
+function parsePrettyArg(logLevelOrOptions) {
+    if (logLevelOrOptions == null) {
+        return {};
+    }
+    if (typeof logLevelOrOptions === "string") {
+        return {
+            logLevel: logLevelOrOptions
+        };
+    }
+    return logLevelOrOptions;
+}
+function attachRecipe(factory, plan) {
+    const loggerFactory = applyRecipe(factory, plan);
+    const chain = {
+        withPinoPretty (logLevelOrOptions) {
+            const pretty = parsePrettyArg(logLevelOrOptions);
+            return attachRecipe(factory, {
+                ...plan,
+                pretty: {
+                    ...plan.pretty,
+                    ...pretty
+                },
+                logLevel: pretty.logLevel ?? plan.logLevel
+            });
+        },
+        withPinoRoll (options) {
+            return attachRecipe(factory, {
+                ...plan,
+                roll: options,
+                logLevel: options.logLevel ?? plan.logLevel
+            });
+        }
+    };
+    return Object.assign(loggerFactory, chain, {
+        and: chain
+    });
+}
+function applyRecipe(factory, plan) {
+    const transport = _pinorecipe.pinoRecipe.transport(plan);
+    const adapter = new _pinoadapater.PinoAdapter(transport ? {
+        transport
+    } : {});
+    return factory.configure({
+        options: {
+            logLevel: plan.logLevel ?? _scribe.DefaultLogLevel
+        },
+        adapter
+    });
+}
 function configureScribe(factory, options, config) {
     const environment = process.env.NODE_ENV ?? _system.DefaultEnvironment;
-    const configs = Array.isArray(config) ? config : [
+    const configs = (Array.isArray(config) ? config : config != null ? [
         config
-    ];
-    const transports = configs.filter((config)=>config.environment && config.environment === environment || true);
-    if (transports.length > 1) {
+    ] : []).filter((item)=>item.environment == null || item.environment === environment);
+    if (configs.length > 1) {
         throw new _scribe.LoggingConfigurationError(`There should only be one configuration per environment for logging`);
     }
-    const transport = transports.at(0)?.transports;
-    const adapter = new _pinoadapater.PinoAdapter({
+    const transport = configs.at(0)?.transports;
+    const adapter = new _pinoadapater.PinoAdapter(transport ? {
         transport
-    });
+    } : {});
     return factory.configure({
         options: {
             ...options,
@@ -92,4 +161,4 @@ function configureScribe(factory, options, config) {
     });
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scribe/scribe-pino/src/scribe-pino.ts"],"sourcesContent":["import { extension } from \"@decohere/nexus/extensibility\";\nimport { DefaultEnvironment, type Environment } from \"@decohere/nexus/system\";\nimport {\n\ttype DefaultLevels,\n\tDefaultLogLevel,\n\ttype Logger,\n\tLoggingConfigurationError,\n\ttype ScribeOptions,\n\tscribe,\n} from \"@decohere/scribe\";\nimport type {\n\tTransportMultiOptions,\n\tTransportPipelineOptions,\n\tTransportSingleOptions,\n} from \"pino\";\n\nimport { PinoAdapter } from \"./pino.adapater.js\";\nimport {\n\ttype PinoPrettyRecipeOptions,\n\ttype PinoRecipePlan,\n\ttype PinoRollRecipeOptions,\n\tpinoRecipe,\n} from \"./pino.recipe.js\";\n\ntype TransportConfig = {\n\tenvironment?: Environment;\n\ttransports: TransportSingleOptions | TransportMultiOptions | TransportPipelineOptions;\n};\n\ntype CustomLevelOptions<T extends string = never, CustomOnly extends true = undefined> = {\n\tscribe?: ScribeOptions<T, CustomOnly>;\n\ttransports?: TransportConfig | TransportConfig[];\n};\n\nexport type PinoLoggerFactory = (name?: string) => Logger;\n\nexport type PinoRecipeChain = {\n\twithPinoPretty(\n\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t): PinoRecipe;\n\twithPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;\n};\n\nexport type PinoRecipe = PinoLoggerFactory &\n\tPinoRecipeChain & {\n\t\treadonly and: PinoRecipeChain;\n\t};\n\ndeclare module \"@decohere/scribe\" {\n\tinterface scribe {\n\t\twithPino(\n\t\t\ttransports: TransportConfig | TransportConfig[],\n\t\t\tloglevel?: DefaultLevels | string,\n\t\t): PinoLoggerFactory;\n\t\t/**\n\t\t * Colorized pretty transport. Development only unless `{ when: \"always\" }`.\n\t\t * Chain with `.and.withPinoRoll({ file })`. Production writes JSON to stdout\n\t\t * so log shipping stays outside the process.\n\t\t */\n\t\twithPinoPretty(\n\t\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t\t): PinoRecipe;\n\t\t/**\n\t\t * Rolling log files. Development only unless `{ when: \"always\" }`.\n\t\t * Do not enable in production — ship stdout from a sidecar or platform agent.\n\t\t */\n\t\twithPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;\n\t\twithPinoCustom<T extends string = never, CustomOnly extends true = undefined>(\n\t\t\toptions?: CustomLevelOptions<T, CustomOnly>,\n\t\t): PinoLoggerFactory;\n\t}\n\tnamespace scribe {\n\t\tfunction withPino(\n\t\t\ttransports: TransportConfig | TransportConfig[],\n\t\t\tloglevel?: DefaultLevels | string,\n\t\t): PinoLoggerFactory;\n\t\tfunction withPinoPretty(\n\t\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t\t): PinoRecipe;\n\t\tfunction withPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;\n\t\tfunction withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(\n\t\t\toptions?: CustomLevelOptions<T, CustomOnly>,\n\t\t): PinoLoggerFactory;\n\t}\n}\n\nexport class PinoExtensions {\n\t@extension(scribe, { static: true })\n\tpublic static withPino(\n\t\tfactory: scribe,\n\t\tconfig: TransportConfig | TransportConfig[],\n\t\tlogLevel?: DefaultLevels | string,\n\t) {\n\t\treturn configureScribe(factory, { logLevel }, config);\n\t}\n\n\t@extension(scribe, { static: true })\n\tpublic static withPinoPretty(\n\t\tfactory: scribe,\n\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t) {\n\t\tconst pretty = parsePrettyArg(logLevelOrOptions);\n\t\treturn attachRecipe(factory, { pretty, logLevel: pretty.logLevel });\n\t}\n\n\t@extension(scribe, { static: true })\n\tpublic static withPinoRoll(factory: scribe, options: PinoRollRecipeOptions) {\n\t\treturn attachRecipe(factory, { roll: options, logLevel: options.logLevel });\n\t}\n\n\t@extension(scribe, { static: true })\n\tpublic static withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(\n\t\tfactory: scribe,\n\t\toptions?: CustomLevelOptions<T, CustomOnly>,\n\t) {\n\t\tconst { scribe, transports } = options ?? {};\n\t\treturn configureScribe(factory, scribe, transports);\n\t}\n}\n\nfunction parsePrettyArg(\n\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n): PinoPrettyRecipeOptions {\n\tif (logLevelOrOptions == null) {\n\t\treturn {};\n\t}\n\tif (typeof logLevelOrOptions === \"string\") {\n\t\treturn { logLevel: logLevelOrOptions };\n\t}\n\treturn logLevelOrOptions;\n}\n\nfunction attachRecipe(factory: scribe, plan: PinoRecipePlan): PinoRecipe {\n\tconst loggerFactory = applyRecipe(factory, plan);\n\tconst chain: PinoRecipeChain = {\n\t\twithPinoPretty(logLevelOrOptions) {\n\t\t\tconst pretty = parsePrettyArg(logLevelOrOptions);\n\t\t\treturn attachRecipe(factory, {\n\t\t\t\t...plan,\n\t\t\t\tpretty: { ...plan.pretty, ...pretty },\n\t\t\t\tlogLevel: pretty.logLevel ?? plan.logLevel,\n\t\t\t});\n\t\t},\n\t\twithPinoRoll(options) {\n\t\t\treturn attachRecipe(factory, {\n\t\t\t\t...plan,\n\t\t\t\troll: options,\n\t\t\t\tlogLevel: options.logLevel ?? plan.logLevel,\n\t\t\t});\n\t\t},\n\t};\n\treturn Object.assign(loggerFactory, chain, { and: chain });\n}\n\nfunction applyRecipe(factory: scribe, plan: PinoRecipePlan): PinoLoggerFactory {\n\tconst transport = pinoRecipe.transport(plan);\n\tconst adapter = new PinoAdapter(transport ? { transport } : {});\n\treturn factory.configure({\n\t\toptions: { logLevel: plan.logLevel ?? DefaultLogLevel },\n\t\tadapter,\n\t});\n}\n\nfunction configureScribe<T extends string = never, CustomOnly extends true | false = false>(\n\tfactory: scribe,\n\toptions: ScribeOptions<T, CustomOnly>,\n\tconfig?: TransportConfig | TransportConfig[],\n) {\n\tconst environment = process.env.NODE_ENV ?? DefaultEnvironment;\n\tconst configs = (Array.isArray(config) ? config : config != null ? [config] : []).filter(\n\t\t(item) => item.environment == null || item.environment === environment,\n\t);\n\n\tif (configs.length > 1) {\n\t\tthrow new LoggingConfigurationError(\n\t\t\t`There should only be one configuration per environment for logging`,\n\t\t);\n\t}\n\n\tconst transport = configs.at(0)?.transports;\n\tconst adapter = new PinoAdapter(transport ? { transport } : {});\n\treturn factory.configure({\n\t\toptions: { ...options, logLevel: options?.logLevel ?? DefaultLogLevel },\n\t\tadapter,\n\t});\n}\n"],"names":["PinoExtensions","withPino","factory","config","logLevel","configureScribe","withPinoPretty","logLevelOrOptions","pretty","parsePrettyArg","attachRecipe","withPinoRoll","options","roll","withPinoCustom","scribe","transports","static","plan","loggerFactory","applyRecipe","chain","Object","assign","and","transport","pinoRecipe","adapter","PinoAdapter","configure","DefaultLogLevel","environment","process","env","NODE_ENV","DefaultEnvironment","configs","Array","isArray","filter","item","length","LoggingConfigurationError","at"],"mappings":"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"}

package/es6/src/index.js

@@ -1,4 +1,5 @@
 export * from "./pino.adapater.js";
+export * from "./pino.recipe.js";
 export * from "./scribe-pino.js";
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUtcGluby9zcmMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vcGluby5hZGFwYXRlci5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vc2NyaWJlLXBpbm8uanNcIjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQjtBQUNuQyxjQUFjLG1CQUFtQiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUtcGluby9zcmMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vcGluby5hZGFwYXRlci5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcGluby5yZWNpcGUuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NjcmliZS1waW5vLmpzXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUI7QUFDbkMsY0FBYyxtQkFBbUI7QUFDakMsY0FBYyxtQkFBbUIifQ==

package/es6/src/pino.recipe.js

@@ -0,0 +1,57 @@
+import { Environments } from "@decohere/nexus/system";
+const DEFAULT_ROLL_SIZE = "10m";
+const DEFAULT_ROLL_FREQUENCY = "daily";
+const DEFAULT_ROLL_KEEP = 14;
+function currentEnvironment() {
+    return process.env.NODE_ENV === Environments.production ? Environments.production : Environments.development;
+}
+function isEnabled(when, environment) {
+    return (when ?? "development") === "always" || environment === Environments.development;
+}
+function prettyTarget(options) {
+    return {
+        target: "pino-pretty",
+        options: {
+            colorize: options.colorize ?? true
+        }
+    };
+}
+function rollTarget(options) {
+    return {
+        target: "pino-roll",
+        options: {
+            file: options.file,
+            mkdir: options.mkdir ?? true,
+            size: options.size ?? DEFAULT_ROLL_SIZE,
+            frequency: options.frequency ?? DEFAULT_ROLL_FREQUENCY,
+            limit: {
+                count: options.keep ?? DEFAULT_ROLL_KEEP
+            },
+            symlink: options.symlink ?? true
+        }
+    };
+}
+function transport(plan, environment = currentEnvironment()) {
+    const targets = [];
+    if (plan.pretty && isEnabled(plan.pretty.when, environment)) {
+        targets.push(prettyTarget(plan.pretty));
+    }
+    if (plan.roll && isEnabled(plan.roll.when, environment)) {
+        targets.push(rollTarget(plan.roll));
+    }
+    if (targets.length === 0) {
+        return undefined;
+    }
+    if (targets.length === 1) {
+        return targets[0];
+    }
+    return {
+        targets
+    };
+}
+export const pinoRecipe = {
+    transport,
+    currentEnvironment
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/scribe-pino.js

@@ -11,29 +11,35 @@ import { extension } from "@decohere/nexus/extensibility";
 import { DefaultEnvironment } from "@decohere/nexus/system";
 import { DefaultLogLevel, LoggingConfigurationError, scribe } from "@decohere/scribe";
 import { PinoAdapter } from "./pino.adapater.js";
+import { pinoRecipe } from "./pino.recipe.js";
 export class PinoExtensions {
     static withPino(factory, config, logLevel) {
         return configureScribe(factory, {
             logLevel
         }, config);
     }
-    static withPinoPretty(factory, logLevel) {
-        return PinoExtensions.withPino(factory, {
-            transports: {
-                target: "pino-pretty",
-                options: {
-                    colorize: true
-                }
-            }
-        }, logLevel);
+    static withPinoPretty(factory, logLevelOrOptions) {
+        const pretty = parsePrettyArg(logLevelOrOptions);
+        return attachRecipe(factory, {
+            pretty,
+            logLevel: pretty.logLevel
+        });
+    }
+    static withPinoRoll(factory, options) {
+        return attachRecipe(factory, {
+            roll: options,
+            logLevel: options.logLevel
+        });
     }
     static withPinoCustom(factory, options) {
-        const { scribe, transports } = options;
+        const { scribe, transports } = options ?? {};
         return configureScribe(factory, scribe, transports);
     }
 }
 _ts_decorate([
-    extension(scribe),
+    extension(scribe, {
+        static: true
+    }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof scribe === "undefined" ? Object : scribe,
@@ -43,7 +49,9 @@ _ts_decorate([
     _ts_metadata("design:returntype", void 0)
 ], PinoExtensions, "withPino", null);
 _ts_decorate([
-    extension(scribe),
+    extension(scribe, {
+        static: true
+    }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof scribe === "undefined" ? Object : scribe,
@@ -52,7 +60,20 @@ _ts_decorate([
     _ts_metadata("design:returntype", void 0)
 ], PinoExtensions, "withPinoPretty", null);
 _ts_decorate([
-    extension(scribe),
+    extension(scribe, {
+        static: true
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof scribe === "undefined" ? Object : scribe,
+        typeof PinoRollRecipeOptions === "undefined" ? Object : PinoRollRecipeOptions
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], PinoExtensions, "withPinoRoll", null);
+_ts_decorate([
+    extension(scribe, {
+        static: true
+    }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof scribe === "undefined" ? Object : scribe,
@@ -60,19 +81,67 @@ _ts_decorate([
     ]),
     _ts_metadata("design:returntype", void 0)
 ], PinoExtensions, "withPinoCustom", null);
+function parsePrettyArg(logLevelOrOptions) {
+    if (logLevelOrOptions == null) {
+        return {};
+    }
+    if (typeof logLevelOrOptions === "string") {
+        return {
+            logLevel: logLevelOrOptions
+        };
+    }
+    return logLevelOrOptions;
+}
+function attachRecipe(factory, plan) {
+    const loggerFactory = applyRecipe(factory, plan);
+    const chain = {
+        withPinoPretty (logLevelOrOptions) {
+            const pretty = parsePrettyArg(logLevelOrOptions);
+            return attachRecipe(factory, {
+                ...plan,
+                pretty: {
+                    ...plan.pretty,
+                    ...pretty
+                },
+                logLevel: pretty.logLevel ?? plan.logLevel
+            });
+        },
+        withPinoRoll (options) {
+            return attachRecipe(factory, {
+                ...plan,
+                roll: options,
+                logLevel: options.logLevel ?? plan.logLevel
+            });
+        }
+    };
+    return Object.assign(loggerFactory, chain, {
+        and: chain
+    });
+}
+function applyRecipe(factory, plan) {
+    const transport = pinoRecipe.transport(plan);
+    const adapter = new PinoAdapter(transport ? {
+        transport
+    } : {});
+    return factory.configure({
+        options: {
+            logLevel: plan.logLevel ?? DefaultLogLevel
+        },
+        adapter
+    });
+}
 function configureScribe(factory, options, config) {
     const environment = process.env.NODE_ENV ?? DefaultEnvironment;
-    const configs = Array.isArray(config) ? config : [
+    const configs = (Array.isArray(config) ? config : config != null ? [
         config
-    ];
-    const transports = configs.filter((config)=>config.environment && config.environment === environment || true);
-    if (transports.length > 1) {
+    ] : []).filter((item)=>item.environment == null || item.environment === environment);
+    if (configs.length > 1) {
         throw new LoggingConfigurationError(`There should only be one configuration per environment for logging`);
     }
-    const transport = transports.at(0)?.transports;
-    const adapter = new PinoAdapter({
+    const transport = configs.at(0)?.transports;
+    const adapter = new PinoAdapter(transport ? {
         transport
-    });
+    } : {});
     return factory.configure({
         options: {
             ...options,
@@ -82,4 +151,4 @@ function configureScribe(factory, options, config) {
     });
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scribe/scribe-pino/src/scribe-pino.ts"],"sourcesContent":["import { extension } from \"@decohere/nexus/extensibility\";\nimport { DefaultEnvironment, type Environment } from \"@decohere/nexus/system\";\nimport {\n\ttype DefaultLevels,\n\tDefaultLogLevel,\n\ttype Logger,\n\tLoggingConfigurationError,\n\ttype ScribeOptions,\n\tscribe,\n} from \"@decohere/scribe\";\nimport type {\n\tTransportMultiOptions,\n\tTransportPipelineOptions,\n\tTransportSingleOptions,\n} from \"pino\";\n\nimport { PinoAdapter } from \"./pino.adapater.js\";\nimport {\n\ttype PinoPrettyRecipeOptions,\n\ttype PinoRecipePlan,\n\ttype PinoRollRecipeOptions,\n\tpinoRecipe,\n} from \"./pino.recipe.js\";\n\ntype TransportConfig = {\n\tenvironment?: Environment;\n\ttransports: TransportSingleOptions | TransportMultiOptions | TransportPipelineOptions;\n};\n\ntype CustomLevelOptions<T extends string = never, CustomOnly extends true = undefined> = {\n\tscribe?: ScribeOptions<T, CustomOnly>;\n\ttransports?: TransportConfig | TransportConfig[];\n};\n\nexport type PinoLoggerFactory = (name?: string) => Logger;\n\nexport type PinoRecipeChain = {\n\twithPinoPretty(\n\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t): PinoRecipe;\n\twithPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;\n};\n\nexport type PinoRecipe = PinoLoggerFactory &\n\tPinoRecipeChain & {\n\t\treadonly and: PinoRecipeChain;\n\t};\n\ndeclare module \"@decohere/scribe\" {\n\tinterface scribe {\n\t\twithPino(\n\t\t\ttransports: TransportConfig | TransportConfig[],\n\t\t\tloglevel?: DefaultLevels | string,\n\t\t): PinoLoggerFactory;\n\t\t/**\n\t\t * Colorized pretty transport. Development only unless `{ when: \"always\" }`.\n\t\t * Chain with `.and.withPinoRoll({ file })`. Production writes JSON to stdout\n\t\t * so log shipping stays outside the process.\n\t\t */\n\t\twithPinoPretty(\n\t\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t\t): PinoRecipe;\n\t\t/**\n\t\t * Rolling log files. Development only unless `{ when: \"always\" }`.\n\t\t * Do not enable in production — ship stdout from a sidecar or platform agent.\n\t\t */\n\t\twithPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;\n\t\twithPinoCustom<T extends string = never, CustomOnly extends true = undefined>(\n\t\t\toptions?: CustomLevelOptions<T, CustomOnly>,\n\t\t): PinoLoggerFactory;\n\t}\n\tnamespace scribe {\n\t\tfunction withPino(\n\t\t\ttransports: TransportConfig | TransportConfig[],\n\t\t\tloglevel?: DefaultLevels | string,\n\t\t): PinoLoggerFactory;\n\t\tfunction withPinoPretty(\n\t\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t\t): PinoRecipe;\n\t\tfunction withPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;\n\t\tfunction withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(\n\t\t\toptions?: CustomLevelOptions<T, CustomOnly>,\n\t\t): PinoLoggerFactory;\n\t}\n}\n\nexport class PinoExtensions {\n\t@extension(scribe, { static: true })\n\tpublic static withPino(\n\t\tfactory: scribe,\n\t\tconfig: TransportConfig | TransportConfig[],\n\t\tlogLevel?: DefaultLevels | string,\n\t) {\n\t\treturn configureScribe(factory, { logLevel }, config);\n\t}\n\n\t@extension(scribe, { static: true })\n\tpublic static withPinoPretty(\n\t\tfactory: scribe,\n\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t) {\n\t\tconst pretty = parsePrettyArg(logLevelOrOptions);\n\t\treturn attachRecipe(factory, { pretty, logLevel: pretty.logLevel });\n\t}\n\n\t@extension(scribe, { static: true })\n\tpublic static withPinoRoll(factory: scribe, options: PinoRollRecipeOptions) {\n\t\treturn attachRecipe(factory, { roll: options, logLevel: options.logLevel });\n\t}\n\n\t@extension(scribe, { static: true })\n\tpublic static withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(\n\t\tfactory: scribe,\n\t\toptions?: CustomLevelOptions<T, CustomOnly>,\n\t) {\n\t\tconst { scribe, transports } = options ?? {};\n\t\treturn configureScribe(factory, scribe, transports);\n\t}\n}\n\nfunction parsePrettyArg(\n\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n): PinoPrettyRecipeOptions {\n\tif (logLevelOrOptions == null) {\n\t\treturn {};\n\t}\n\tif (typeof logLevelOrOptions === \"string\") {\n\t\treturn { logLevel: logLevelOrOptions };\n\t}\n\treturn logLevelOrOptions;\n}\n\nfunction attachRecipe(factory: scribe, plan: PinoRecipePlan): PinoRecipe {\n\tconst loggerFactory = applyRecipe(factory, plan);\n\tconst chain: PinoRecipeChain = {\n\t\twithPinoPretty(logLevelOrOptions) {\n\t\t\tconst pretty = parsePrettyArg(logLevelOrOptions);\n\t\t\treturn attachRecipe(factory, {\n\t\t\t\t...plan,\n\t\t\t\tpretty: { ...plan.pretty, ...pretty },\n\t\t\t\tlogLevel: pretty.logLevel ?? plan.logLevel,\n\t\t\t});\n\t\t},\n\t\twithPinoRoll(options) {\n\t\t\treturn attachRecipe(factory, {\n\t\t\t\t...plan,\n\t\t\t\troll: options,\n\t\t\t\tlogLevel: options.logLevel ?? plan.logLevel,\n\t\t\t});\n\t\t},\n\t};\n\treturn Object.assign(loggerFactory, chain, { and: chain });\n}\n\nfunction applyRecipe(factory: scribe, plan: PinoRecipePlan): PinoLoggerFactory {\n\tconst transport = pinoRecipe.transport(plan);\n\tconst adapter = new PinoAdapter(transport ? { transport } : {});\n\treturn factory.configure({\n\t\toptions: { logLevel: plan.logLevel ?? DefaultLogLevel },\n\t\tadapter,\n\t});\n}\n\nfunction configureScribe<T extends string = never, CustomOnly extends true | false = false>(\n\tfactory: scribe,\n\toptions: ScribeOptions<T, CustomOnly>,\n\tconfig?: TransportConfig | TransportConfig[],\n) {\n\tconst environment = process.env.NODE_ENV ?? DefaultEnvironment;\n\tconst configs = (Array.isArray(config) ? config : config != null ? [config] : []).filter(\n\t\t(item) => item.environment == null || item.environment === environment,\n\t);\n\n\tif (configs.length > 1) {\n\t\tthrow new LoggingConfigurationError(\n\t\t\t`There should only be one configuration per environment for logging`,\n\t\t);\n\t}\n\n\tconst transport = configs.at(0)?.transports;\n\tconst adapter = new PinoAdapter(transport ? { transport } : {});\n\treturn factory.configure({\n\t\toptions: { ...options, logLevel: options?.logLevel ?? DefaultLogLevel },\n\t\tadapter,\n\t});\n}\n"],"names":["extension","DefaultEnvironment","DefaultLogLevel","LoggingConfigurationError","scribe","PinoAdapter","pinoRecipe","PinoExtensions","withPino","factory","config","logLevel","configureScribe","withPinoPretty","logLevelOrOptions","pretty","parsePrettyArg","attachRecipe","withPinoRoll","options","roll","withPinoCustom","transports","static","plan","loggerFactory","applyRecipe","chain","Object","assign","and","transport","adapter","configure","environment","process","env","NODE_ENV","configs","Array","isArray","filter","item","length","at"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/scribe-pino",
-  "version": "0.0.1-dev.65",
+  "version": "0.0.1-dev.67",
   "description": "Pino adapter for @decohere/scribe",
   "keywords": [
     "typescript",
@@ -23,9 +23,21 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@decohere/nexus": "0.0.1-dev.65",
-    "@decohere/scribe": "0.0.1-dev.65",
+    "@decohere/nexus": "0.0.1-dev.67",
+    "@decohere/scribe": "0.0.1-dev.67",
     "pino": "^10.3.0"
   },
-  "devDependencies": {}
+  "devDependencies": {},
+  "peerDependencies": {
+    "pino-pretty": "^13.0.0",
+    "pino-roll": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "pino-pretty": {
+      "optional": true
+    },
+    "pino-roll": {
+      "optional": true
+    }
+  }
 }

package/types/src/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./pino.adapater.js";
+export * from "./pino.recipe.js";
 export * from "./scribe-pino.js";

package/types/src/pino.recipe.d.ts

@@ -0,0 +1,31 @@
+import { type Environment } from "@decohere/nexus/system";
+import type { TransportMultiOptions, TransportSingleOptions } from "pino";
+/** Pretty and roll are local-dev conveniences. Production ships JSON on stdout. */
+export type PinoWhen = "development" | "always";
+export type PinoPrettyRecipeOptions = {
+    colorize?: boolean;
+    logLevel?: string;
+    when?: PinoWhen;
+};
+export type PinoRollRecipeOptions = {
+    file: string;
+    size?: string;
+    frequency?: string | number;
+    keep?: number;
+    mkdir?: boolean;
+    symlink?: boolean;
+    logLevel?: string;
+    when?: PinoWhen;
+};
+export type PinoRecipePlan = {
+    pretty?: PinoPrettyRecipeOptions;
+    roll?: PinoRollRecipeOptions;
+    logLevel?: string;
+};
+declare function currentEnvironment(): Environment;
+declare function transport(plan: PinoRecipePlan, environment?: Environment): TransportSingleOptions | TransportMultiOptions | undefined;
+export declare const pinoRecipe: {
+    transport: typeof transport;
+    currentEnvironment: typeof currentEnvironment;
+};
+export {};

package/types/src/scribe-pino.d.ts

@@ -1,6 +1,7 @@
 import { type Environment } from "@decohere/nexus/system";
 import { type DefaultLevels, type Logger, type ScribeOptions, scribe } from "@decohere/scribe";
 import type { TransportMultiOptions, TransportPipelineOptions, TransportSingleOptions } from "pino";
+import { type PinoPrettyRecipeOptions, type PinoRollRecipeOptions } from "./pino.recipe.js";
 type TransportConfig = {
     environment?: Environment;
     transports: TransportSingleOptions | TransportMultiOptions | TransportPipelineOptions;
@@ -9,16 +10,41 @@ type CustomLevelOptions<T extends string = never, CustomOnly extends true = unde
     scribe?: ScribeOptions<T, CustomOnly>;
     transports?: TransportConfig | TransportConfig[];
 };
+export type PinoLoggerFactory = (name?: string) => Logger;
+export type PinoRecipeChain = {
+    withPinoPretty(logLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions): PinoRecipe;
+    withPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;
+};
+export type PinoRecipe = PinoLoggerFactory & PinoRecipeChain & {
+    readonly and: PinoRecipeChain;
+};
 declare module "@decohere/scribe" {
     interface scribe {
-        withPino(transports: TransportConfig | TransportConfig[], loglevel?: DefaultLevels | string): (name?: string) => Logger;
-        withPinoPretty(logLevel?: DefaultLevels | string): (name?: string) => Logger;
-        withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(options?: CustomLevelOptions<T, CustomOnly>): (name?: string) => Logger<T, CustomOnly>;
+        withPino(transports: TransportConfig | TransportConfig[], loglevel?: DefaultLevels | string): PinoLoggerFactory;
+        /**
+         * Colorized pretty transport. Development only unless `{ when: "always" }`.
+         * Chain with `.and.withPinoRoll({ file })`. Production writes JSON to stdout
+         * so log shipping stays outside the process.
+         */
+        withPinoPretty(logLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions): PinoRecipe;
+        /**
+         * Rolling log files. Development only unless `{ when: "always" }`.
+         * Do not enable in production — ship stdout from a sidecar or platform agent.
+         */
+        withPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;
+        withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(options?: CustomLevelOptions<T, CustomOnly>): PinoLoggerFactory;
+    }
+    namespace scribe {
+        function withPino(transports: TransportConfig | TransportConfig[], loglevel?: DefaultLevels | string): PinoLoggerFactory;
+        function withPinoPretty(logLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions): PinoRecipe;
+        function withPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;
+        function withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(options?: CustomLevelOptions<T, CustomOnly>): PinoLoggerFactory;
     }
 }
 export declare class PinoExtensions {
     static withPino(factory: scribe, config: TransportConfig | TransportConfig[], logLevel?: DefaultLevels | string): (name?: string) => Logger<never, false>;
-    static withPinoPretty(factory: scribe, logLevel?: DefaultLevels | string): (name?: string) => Logger<never, false>;
+    static withPinoPretty(factory: scribe, logLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions): PinoRecipe;
+    static withPinoRoll(factory: scribe, options: PinoRollRecipeOptions): PinoRecipe;
     static withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(factory: scribe, options?: CustomLevelOptions<T, CustomOnly>): (name?: string) => Logger<T, CustomOnly>;
 }
 export {};