flexily 0.5.2 → 0.6.0

package/dist/node-zero-75maLs2s.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-zero-75maLs2s.d.mts","names":[],"sources":["../src/node-zero.ts"],"mappings":"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"}

package/dist/src-BWyhokNZ.mjs

@@ -0,0 +1,692 @@
+import { closeSync, openSync, writeSync } from "node:fs";
+//#region ../loggily/src/colors.ts
+/**
+* Vendored ANSI color functions — replaces picocolors dependency.
+* Supports NO_COLOR, FORCE_COLOR, and TTY detection.
+*/
+const _process$1 = typeof process !== "undefined" ? process : void 0;
+const enabled = _process$1?.env?.["FORCE_COLOR"] !== void 0 && _process$1?.env?.["FORCE_COLOR"] !== "0" ? true : _process$1?.env?.["NO_COLOR"] !== void 0 ? false : _process$1?.stdout?.isTTY ?? false;
+function wrap(open, close) {
+	if (!enabled) return (str) => str;
+	return (str) => open + str + close;
+}
+const colors = {
+	dim: wrap("\x1B[2m", "\x1B[22m"),
+	blue: wrap("\x1B[34m", "\x1B[39m"),
+	yellow: wrap("\x1B[33m", "\x1B[39m"),
+	red: wrap("\x1B[31m", "\x1B[39m"),
+	magenta: wrap("\x1B[35m", "\x1B[39m"),
+	cyan: wrap("\x1B[36m", "\x1B[39m")
+};
+//#endregion
+//#region ../loggily/src/file-writer.ts
+/**
+* File writer for loggily — Node.js/Bun only.
+*
+* Separated from core logger to allow tree-shaking in browser bundles.
+* Uses dynamic import("node:fs") to avoid static dependency on Node APIs.
+*/
+/**
+* Create an async buffered file writer for log output.
+* Buffers writes and flushes on size threshold or interval.
+* Registers a process.on('exit') handler to flush remaining buffer.
+*
+* **Node.js/Bun only** — not available in browser environments.
+*
+* @param filePath - Path to the log file (opened in append mode)
+* @param options - Buffer size and flush interval configuration
+* @returns FileWriter with write, flush, and close methods
+*
+* @example
+* const writer = createFileWriter('/tmp/app.log')
+* const unsubscribe = addWriter((formatted) => writer.write(formatted))
+*
+* // On shutdown:
+* unsubscribe()
+* writer.close()
+*/
+function createFileWriter(filePath, options = {}) {
+	const bufferSize = options.bufferSize ?? 4096;
+	const flushInterval = options.flushInterval ?? 100;
+	let buffer = "";
+	let fd = null;
+	let timer = null;
+	let closed = false;
+	fd = openSync(filePath, "a");
+	/** Flush buffer contents to disk synchronously */
+	function flush() {
+		if (buffer.length === 0 || fd === null) return;
+		writeSync(fd, buffer);
+		buffer = "";
+	}
+	timer = setInterval(flush, flushInterval);
+	if (timer && typeof timer === "object" && "unref" in timer) timer.unref();
+	const exitHandler = () => flush();
+	process.on("exit", exitHandler);
+	return {
+		write(line) {
+			if (closed) return;
+			buffer += line + "\n";
+			if (buffer.length >= bufferSize) flush();
+		},
+		flush,
+		close() {
+			if (closed) return;
+			closed = true;
+			if (timer !== null) {
+				clearInterval(timer);
+				timer = null;
+			}
+			try {
+				flush();
+			} catch {} finally {
+				if (fd !== null) {
+					closeSync(fd);
+					fd = null;
+				}
+				process.removeListener("exit", exitHandler);
+			}
+		}
+	};
+}
+//#endregion
+//#region ../loggily/src/pipeline.ts
+const LOG_LEVEL_PRIORITY = {
+	trace: 0,
+	debug: 1,
+	info: 2,
+	warn: 3,
+	error: 4,
+	silent: 5
+};
+const _process = typeof process !== "undefined" ? process : void 0;
+function getEnv(key) {
+	return _process?.env?.[key];
+}
+function writeStderr(text) {
+	if (_process?.stderr?.write) _process.stderr.write(text + "\n");
+	else console.error(text);
+}
+function safeStringify(value) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	return JSON.stringify(value, (_key, val) => {
+		if (typeof val === "bigint") return val.toString();
+		if (typeof val === "symbol") return val.toString();
+		if (val instanceof Error) return {
+			message: val.message,
+			stack: val.stack,
+			name: val.name
+		};
+		if (typeof val === "object" && val !== null) {
+			if (seen.has(val)) return "[Circular]";
+			seen.add(val);
+		}
+		return val;
+	});
+}
+function formatConsoleEvent(event) {
+	const time = colors.dim(new Date(event.time).toISOString().split("T")[1]?.split(".")[0] || "");
+	const ns = colors.cyan(event.namespace);
+	if (event.kind === "span") {
+		const message = `(${event.duration}ms)`;
+		let output = `${time} ${colors.magenta("SPAN")} ${ns} ${message}`;
+		if (event.props && Object.keys(event.props).length > 0) output += ` ${colors.dim(safeStringify(event.props))}`;
+		return output;
+	}
+	let levelStr;
+	switch (event.level) {
+		case "trace":
+			levelStr = colors.dim("TRACE");
+			break;
+		case "debug":
+			levelStr = colors.dim("DEBUG");
+			break;
+		case "info":
+			levelStr = colors.blue("INFO");
+			break;
+		case "warn":
+			levelStr = colors.yellow("WARN");
+			break;
+		case "error":
+			levelStr = colors.red("ERROR");
+			break;
+	}
+	let output = `${time} ${levelStr} ${ns} ${event.message}`;
+	if (event.props && Object.keys(event.props).length > 0) output += ` ${colors.dim(safeStringify(event.props))}`;
+	return output;
+}
+function formatJSONEvent(event) {
+	if (event.kind === "span") return safeStringify({
+		time: new Date(event.time).toISOString(),
+		level: "span",
+		name: event.namespace,
+		msg: `(${event.duration}ms)`,
+		duration: event.duration,
+		span_id: event.spanId,
+		trace_id: event.traceId,
+		parent_id: event.parentId,
+		...event.props
+	});
+	return safeStringify({
+		time: new Date(event.time).toISOString(),
+		level: event.level,
+		name: event.namespace,
+		msg: event.message,
+		...event.props
+	});
+}
+function matchesPattern(namespace, pattern) {
+	if (pattern === "*") return true;
+	return namespace === pattern || namespace.startsWith(pattern + ":");
+}
+function parseNsFilter(ns) {
+	const patterns = typeof ns === "string" ? ns.split(",").map((s) => s.trim()) : ns;
+	const includes = [];
+	const excludes = [];
+	for (const p of patterns) if (p.startsWith("-")) excludes.push(p.slice(1));
+	else includes.push(p);
+	return (namespace) => {
+		for (const exc of excludes) if (matchesPattern(namespace, exc)) return false;
+		if (includes.length > 0) {
+			for (const inc of includes) if (matchesPattern(namespace, inc)) return true;
+			return false;
+		}
+		return true;
+	};
+}
+function createConsoleSink(format) {
+	const formatter = format === "json" ? formatJSONEvent : formatConsoleEvent;
+	return (event) => {
+		const text = formatter(event);
+		if (event.kind === "span") {
+			writeStderr(text);
+			return;
+		}
+		switch (event.level) {
+			case "trace":
+			case "debug":
+				console.debug(text);
+				break;
+			case "info":
+				console.info(text);
+				break;
+			case "warn":
+				console.warn(text);
+				break;
+			case "error":
+				console.error(text);
+				break;
+		}
+	};
+}
+function createFileSink(path, format) {
+	const writer = createFileWriter(path);
+	const formatter = format === "json" ? formatJSONEvent : formatConsoleEvent;
+	return {
+		write: (event) => writer.write(formatter(event)),
+		dispose: () => writer.close()
+	};
+}
+function createWritableSink(writable, format) {
+	const formatter = format === "json" ? formatJSONEvent : formatConsoleEvent;
+	return (event) => writable.write(formatter(event) + "\n");
+}
+const VALID_CONFIG_KEYS = new Set([
+	"level",
+	"ns",
+	"format"
+]);
+const SINK_KEYS = new Set(["file", "otel"]);
+function isPojo(obj) {
+	if (typeof obj !== "object" || obj === null) return false;
+	const proto = Object.getPrototypeOf(obj);
+	return proto === Object.prototype || proto === null;
+}
+function isWritable(obj) {
+	return typeof obj === "object" && obj !== null && "write" in obj && typeof obj.write === "function" && !isPojo(obj);
+}
+function isValidLogLevel(val) {
+	return typeof val === "string" && val in LOG_LEVEL_PRIORITY;
+}
+function buildPipeline(elements, parentConfig) {
+	const config = {
+		level: parentConfig?.level ?? readEnvLevel(),
+		ns: parentConfig?.ns ?? readEnvNs(),
+		format: parentConfig?.format ?? readEnvFormat()
+	};
+	const stages = [];
+	const outputs = [];
+	const branches = [];
+	const disposables = [];
+	for (const element of elements) {
+		if (Array.isArray(element)) {
+			const branch = buildPipeline(element, { ...config });
+			branches.push(branch);
+			disposables.push(() => branch.dispose());
+			continue;
+		}
+		if (typeof element === "function" && element !== console) {
+			stages.push(element);
+			continue;
+		}
+		if (element === console) {
+			outputs.push({
+				levelPriority: LOG_LEVEL_PRIORITY[config.level],
+				nsFilter: config.ns,
+				write: createConsoleSink(config.format)
+			});
+			continue;
+		}
+		if (isWritable(element)) {
+			outputs.push({
+				levelPriority: LOG_LEVEL_PRIORITY[config.level],
+				nsFilter: config.ns,
+				write: createWritableSink(element, config.format)
+			});
+			continue;
+		}
+		if (isPojo(element)) {
+			const obj = element;
+			const keys = Object.keys(obj);
+			const hasSinkKey = keys.some((k) => SINK_KEYS.has(k));
+			if (keys.some((k) => !VALID_CONFIG_KEYS.has(k) && !SINK_KEYS.has(k))) {
+				const unknown = keys.find((k) => !VALID_CONFIG_KEYS.has(k) && !SINK_KEYS.has(k));
+				throw new Error(`loggily: unknown config key "${unknown}" in config object. Valid keys: ${[...VALID_CONFIG_KEYS, ...SINK_KEYS].join(", ")}`);
+			}
+			if (hasSinkKey) {
+				if (typeof obj.file === "string") {
+					const outputLevel = isValidLogLevel(obj.level) ? obj.level : config.level;
+					const outputNs = obj.ns ? parseNsFilter(obj.ns) : config.ns;
+					const outputFormat = obj.format ?? config.format;
+					const sink = createFileSink(obj.file, outputFormat);
+					disposables.push(sink.dispose);
+					outputs.push({
+						levelPriority: LOG_LEVEL_PRIORITY[outputLevel],
+						nsFilter: outputNs,
+						write: sink.write,
+						dispose: sink.dispose
+					});
+				}
+				continue;
+			}
+			if (isValidLogLevel(obj.level)) config.level = obj.level;
+			if (obj.ns !== void 0) config.ns = parseNsFilter(obj.ns);
+			if (obj.format === "console" || obj.format === "json") config.format = obj.format;
+			continue;
+		}
+		throw new Error(`loggily: unsupported config element of type "${typeof element}". Config arrays accept: objects (config), arrays (branches), functions (stages), console, or writables ({ write }).`);
+	}
+	const dispatch = (event) => {
+		let e = event;
+		for (const stage of stages) {
+			const result = stage(e);
+			if (result === null) return;
+			if (result !== void 0) e = result;
+		}
+		for (const output of outputs) {
+			if (e.kind === "log" && LOG_LEVEL_PRIORITY[e.level] < output.levelPriority) continue;
+			if (output.nsFilter && !output.nsFilter(e.namespace)) continue;
+			output.write(e);
+		}
+		for (const branch of branches) branch.dispatch(e);
+	};
+	return {
+		dispatch,
+		level: config.level,
+		dispose: () => {
+			for (const d of disposables) d();
+		}
+	};
+}
+const runtimeState = {
+	suppressConsole: false,
+	writers: []
+};
+function defaultPipeline() {
+	const rt = runtimeState;
+	const disposables = [];
+	let fileSink = null;
+	const logFile = getEnv("LOG_FILE");
+	if (logFile) {
+		const sink = createFileSink(logFile, "json");
+		fileSink = sink.write;
+		disposables.push(sink.dispose);
+	}
+	const dispatch = (event) => {
+		const currentLevel = readEnvLevel();
+		if (event.kind === "log") {
+			if (LOG_LEVEL_PRIORITY[event.level] < LOG_LEVEL_PRIORITY[currentLevel]) return;
+		} else if (event.kind === "span") {
+			const trace = readEnvTrace();
+			if (!trace.enabled) return;
+			if (trace.filter && !trace.filter(event.namespace)) return;
+		}
+		const currentNs = readEnvNs();
+		if (currentNs && !currentNs(event.namespace)) return;
+		const formatter = readEnvFormat() === "json" || getEnv("NODE_ENV") === "production" || getEnv("TRACE_FORMAT") === "json" ? formatJSONEvent : formatConsoleEvent;
+		if (rt.writers.length > 0) {
+			const formatted = formatter(event);
+			const lvl = event.kind === "log" ? event.level : "span";
+			for (const w of rt.writers) w(formatted, lvl);
+		}
+		if (rt.suppressConsole) {
+			fileSink?.(event);
+			return;
+		}
+		const text = formatter(event);
+		if (event.kind === "span") writeStderr(text);
+		else switch (event.level) {
+			case "trace":
+			case "debug":
+				console.debug(text);
+				break;
+			case "info":
+				console.info(text);
+				break;
+			case "warn":
+				console.warn(text);
+				break;
+			case "error":
+				console.error(text);
+				break;
+		}
+		fileSink?.(event);
+	};
+	return {
+		dispatch,
+		get level() {
+			return readEnvLevel();
+		},
+		dispose: () => {
+			for (const d of disposables) d();
+		}
+	};
+}
+function readEnvLevel() {
+	const env = getEnv("LOG_LEVEL")?.toLowerCase();
+	let level = env === "trace" || env === "debug" || env === "info" || env === "warn" || env === "error" || env === "silent" ? env : "info";
+	if (getEnv("DEBUG") && LOG_LEVEL_PRIORITY[level] > LOG_LEVEL_PRIORITY.debug) level = "debug";
+	return level;
+}
+function readEnvNs() {
+	const debugEnv = getEnv("DEBUG");
+	if (!debugEnv) return null;
+	return parseNsFilter(debugEnv.split(",").map((s) => s.trim()));
+}
+function readEnvFormat() {
+	const envFormat = getEnv("LOG_FORMAT")?.toLowerCase();
+	if (envFormat === "json") return "json";
+	if (envFormat === "console") return "console";
+	if (getEnv("TRACE_FORMAT") === "json") return "json";
+	if (getEnv("NODE_ENV") === "production") return "json";
+	return "console";
+}
+function readEnvTrace() {
+	const traceEnv = getEnv("TRACE");
+	if (!traceEnv) return {
+		enabled: false,
+		filter: null
+	};
+	if (traceEnv === "1" || traceEnv === "true") return {
+		enabled: true,
+		filter: null
+	};
+	const prefixes = traceEnv.split(",").map((s) => s.trim());
+	return {
+		enabled: true,
+		filter: (namespace) => {
+			for (const prefix of prefixes) if (matchesPattern(namespace, prefix)) return true;
+			return false;
+		}
+	};
+}
+//#endregion
+//#region ../loggily/src/tracing.ts
+let currentIdFormat = "simple";
+let simpleSpanCounter = 0;
+let simpleTraceCounter = 0;
+/** Generate a hex string of the given byte length using crypto.randomUUID */
+function randomHex(bytes) {
+	return crypto.randomUUID().replace(/-/g, "").slice(0, bytes * 2);
+}
+/** Generate a span ID according to the current format */
+function generateSpanId() {
+	if (currentIdFormat === "w3c") return randomHex(8);
+	return `sp_${(++simpleSpanCounter).toString(36)}`;
+}
+/** Generate a trace ID according to the current format */
+function generateTraceId() {
+	if (currentIdFormat === "w3c") return randomHex(16);
+	return `tr_${(++simpleTraceCounter).toString(36)}`;
+}
+let sampleRate = 1;
+/**
+* Determine whether a new trace should be sampled.
+* Called at trace creation time (head-based sampling).
+*/
+function shouldSample() {
+	if (sampleRate >= 1) return true;
+	if (sampleRate <= 0) return false;
+	return Math.random() < sampleRate;
+}
+//#endregion
+//#region ../loggily/src/core.ts
+/**
+* loggily v2 — Structured logging with spans
+*
+* One import. Objects configure. Arrays branch. Values write.
+*
+* @example
+* const log = createLogger('myapp')
+* log.info?.('starting')
+*
+* @example
+* const log = createLogger('myapp', [
+*   { level: 'debug', ns: '-sql' },
+*   console,
+*   { file: '/tmp/app.log', level: 'info', format: 'json' },
+* ])
+* log.info?.('server started', { port: 3000 })
+*/
+/** @internal */
+let _ambientRecorder = null;
+let _getContextTags = null;
+let _enterContext = null;
+let _exitContext = null;
+function createSpanDataProxy(getFields, attrs) {
+	const READONLY_KEYS = new Set([
+		"id",
+		"traceId",
+		"parentId",
+		"startTime",
+		"endTime",
+		"duration"
+	]);
+	return new Proxy(attrs, {
+		get(_target, prop) {
+			if (READONLY_KEYS.has(prop)) return getFields()[prop];
+			return attrs[prop];
+		},
+		set(_target, prop, value) {
+			if (READONLY_KEYS.has(prop)) return false;
+			attrs[prop] = value;
+			return true;
+		}
+	});
+}
+function resolveMessage(msg) {
+	return typeof msg === "function" ? msg() : msg;
+}
+function createLoggerImpl(name, props, pipeline, spanMeta, parentSpanId, traceId, traceSampled = true) {
+	const emitLog = (level, msgOrError, dataOrMsg, extraData) => {
+		let message;
+		let data;
+		if (msgOrError instanceof Error) {
+			const err = msgOrError;
+			if (typeof dataOrMsg === "string") {
+				message = dataOrMsg;
+				data = {
+					...props,
+					...extraData,
+					error_type: err.name,
+					error_message: err.message,
+					error_stack: err.stack,
+					error_code: err.code
+				};
+			} else {
+				message = err.message;
+				data = {
+					...props,
+					...dataOrMsg,
+					error_type: err.name,
+					error_stack: err.stack,
+					error_code: err.code
+				};
+			}
+		} else {
+			message = resolveMessage(msgOrError);
+			const contextTags = _getContextTags?.();
+			data = contextTags && Object.keys(contextTags).length > 0 ? {
+				...contextTags,
+				...props,
+				...dataOrMsg
+			} : Object.keys(props).length > 0 || dataOrMsg ? {
+				...props,
+				...dataOrMsg
+			} : void 0;
+		}
+		const event = {
+			kind: "log",
+			time: Date.now(),
+			namespace: name,
+			level,
+			message,
+			props: data
+		};
+		pipeline.dispatch(event);
+	};
+	return {
+		name,
+		props: Object.freeze({ ...props }),
+		get spanData() {
+			if (!spanMeta) return null;
+			return createSpanDataProxy(() => ({
+				id: spanMeta.id,
+				traceId: spanMeta.traceId,
+				parentId: spanMeta.parentId,
+				startTime: spanMeta.startTime,
+				endTime: spanMeta.endTime,
+				duration: spanMeta.endTime !== null ? spanMeta.endTime - spanMeta.startTime : Date.now() - spanMeta.startTime
+			}), spanMeta.attrs);
+		},
+		trace: (msg, data) => emitLog("trace", msg, data),
+		debug: (msg, data) => emitLog("debug", msg, data),
+		info: (msg, data) => emitLog("info", msg, data),
+		warn: (msg, data) => emitLog("warn", msg, data),
+		error: (msgOrError, dataOrMsg, extraData) => emitLog("error", msgOrError, dataOrMsg, extraData),
+		logger(namespace, childProps) {
+			return wrapConditional(createLoggerImpl(namespace ? `${name}:${namespace}` : name, {
+				...props,
+				...childProps
+			}, pipeline, null, parentSpanId, traceId, traceSampled), () => pipeline.level);
+		},
+		span(namespace, childProps) {
+			const childName = namespace ? `${name}:${namespace}` : name;
+			const resolvedChildProps = typeof childProps === "function" ? childProps() : childProps;
+			const mergedProps = {
+				...props,
+				...resolvedChildProps
+			};
+			const newSpanId = generateSpanId();
+			let resolvedParentId = parentSpanId;
+			let resolvedTraceId = traceId;
+			const isNewTrace = !resolvedTraceId;
+			const finalTraceId = resolvedTraceId || generateTraceId();
+			const sampled = isNewTrace ? shouldSample() : traceSampled;
+			const newSpanData = {
+				id: newSpanId,
+				traceId: finalTraceId,
+				parentId: resolvedParentId,
+				startTime: Date.now(),
+				endTime: null,
+				duration: null,
+				attrs: {}
+			};
+			const spanLogger = createLoggerImpl(childName, mergedProps, pipeline, newSpanData, newSpanId, finalTraceId, sampled);
+			_enterContext?.(newSpanId, finalTraceId, resolvedParentId);
+			spanLogger[Symbol.dispose] = () => {
+				if (newSpanData.endTime !== null) return;
+				newSpanData.endTime = Date.now();
+				newSpanData.duration = newSpanData.endTime - newSpanData.startTime;
+				_exitContext?.(newSpanId);
+				_ambientRecorder?.recordSpan({
+					name: childName,
+					durationMs: newSpanData.duration
+				});
+				if (sampled) {
+					const spanEvent = {
+						kind: "span",
+						time: newSpanData.endTime,
+						namespace: childName,
+						name: childName,
+						duration: newSpanData.duration,
+						props: {
+							...mergedProps,
+							...newSpanData.attrs
+						},
+						spanId: newSpanData.id,
+						traceId: newSpanData.traceId,
+						parentId: newSpanData.parentId
+					};
+					pipeline.dispatch(spanEvent);
+				}
+			};
+			return spanLogger;
+		},
+		child(context) {
+			if (typeof context === "string") return this.logger(context);
+			return wrapConditional(createLoggerImpl(name, {
+				...props,
+				...context
+			}, pipeline, null, parentSpanId, traceId, traceSampled), () => pipeline.level);
+		},
+		end() {
+			if (spanMeta?.endTime === null) this[Symbol.dispose]?.();
+		}
+	};
+}
+function wrapConditional(logger, getLevel) {
+	return new Proxy(logger, { get(target, prop) {
+		if (prop in LOG_LEVEL_PRIORITY && prop !== "silent") {
+			if (LOG_LEVEL_PRIORITY[prop] < LOG_LEVEL_PRIORITY[getLevel()]) return;
+		}
+		return target[prop];
+	} });
+}
+/**
+* Create a logger.
+*
+* @param name - Logger namespace (e.g., 'myapp', 'myapp:db')
+* @param config - Optional config array. Objects configure, arrays branch, values write.
+*
+* @example
+* // Zero config (reads LOG_LEVEL, DEBUG, LOG_FORMAT from env)
+* const log = createLogger('myapp')
+*
+* @example
+* // Configured pipeline
+* const log = createLogger('myapp', [
+*   { level: 'debug', ns: '-sql' },
+*   console,
+*   { file: '/tmp/app.log', level: 'info', format: 'json' },
+* ])
+*/
+function createLogger(name, config) {
+	const pipeline = config ? buildPipeline(config) : defaultPipeline();
+	return wrapConditional(createLoggerImpl(name, {}, pipeline, null, null, null), () => pipeline.level);
+}
+(typeof process !== "undefined" ? process : void 0)?.env;
+//#endregion
+export { createLogger };
+
+//# sourceMappingURL=src-BWyhokNZ.mjs.map