zeed 1.2.4 → 1.3.1

package/dist/node/log/log-rotation.d.cts

@@ -1,112 +1,2 @@
-import { Buffer } from 'node:buffer';
-import { Writable } from 'node:stream';
-
-declare class RotatingFileStreamError extends Error {
-    code: string;
-    constructor();
-}
-type RotationCompressor = (source: string, dest: string) => string;
-type RotationGenerator = (time: number | Date | null, index?: number) => string;
-type RotationIntervalUnit = 'M' | 'd' | 'h' | 'm' | 's';
-type RotationInterval = `${number}${RotationIntervalUnit}`;
-type RotationFileSizeUnit = 'B' | 'K' | 'M' | 'G';
-type RotationFileSize = `${number}${RotationFileSizeUnit}`;
-interface RotationOptions {
-    compress?: boolean | 'gzip' | RotationCompressor;
-    encoding?: BufferEncoding;
-    history?: string;
-    immutable?: boolean;
-    initialRotation?: boolean;
-    interval?: RotationInterval;
-    intervalBoundary?: boolean;
-    intervalUTC?: boolean;
-    maxFiles?: number;
-    maxSize?: RotationFileSize;
-    mode?: number;
-    omitExtension?: boolean;
-    path?: string;
-    rotate?: number;
-    size?: RotationFileSize;
-    teeToStdout?: boolean;
-}
-interface Opts {
-    compress?: boolean | 'gzip' | RotationCompressor;
-    encoding?: BufferEncoding;
-    history?: string;
-    immutable?: boolean;
-    initialRotation?: boolean;
-    interval?: {
-        num: number;
-        unit: RotationIntervalUnit;
-    };
-    intervalBoundary?: boolean;
-    intervalUTC?: boolean;
-    maxFiles?: number;
-    maxSize?: number;
-    mode?: number;
-    omitExtension?: boolean;
-    path?: string;
-    rotate?: number;
-    size?: number;
-    teeToStdout?: boolean;
-}
-type RotationCallback = (error?: Error) => void;
-interface RotationChunk {
-    chunk: Buffer;
-    encoding: BufferEncoding;
-}
-declare class RotatingFileStream extends Writable {
-    private createGzip;
-    private exec;
-    private file;
-    private filename;
-    private finished;
-    private fsCreateReadStream;
-    private fsCreateWriteStream;
-    private fsOpen;
-    private fsReadFile;
-    private fsStat;
-    private fsUnlink;
-    private generator;
-    private last;
-    private maxTimeout;
-    private next;
-    private options;
-    private size;
-    private stdout;
-    private prev;
-    private rotation;
-    private initPromise;
-    private timeout;
-    private timeoutPromise;
-    constructor(generator: RotationGenerator, options: Opts);
-    _destroy(error: Error, callback: RotationCallback): void;
-    _final(callback: RotationCallback): void;
-    _write(chunk: Buffer, encoding: BufferEncoding, callback: RotationCallback): void;
-    _writev(chunks: RotationChunk[], callback: RotationCallback): void;
-    private refinal;
-    private rewrite;
-    private init;
-    private makePath;
-    private reopen;
-    private reclose;
-    private now;
-    private rotate;
-    private findName;
-    private move;
-    private touch;
-    private classical;
-    private clear;
-    private intervalBoundsBig;
-    private intervalBounds;
-    private interval;
-    private compress;
-    private gzip;
-    private rotated;
-    private history;
-    private immutate;
-    private unlink;
-}
-declare function createRotationStream(filename: string | RotationGenerator, options?: RotationOptions): RotatingFileStream;
-
-export { RotatingFileStream, RotatingFileStreamError, type RotationCompressor, type RotationFileSize, type RotationFileSizeUnit, type RotationGenerator, type RotationInterval, type RotationIntervalUnit, type RotationOptions, createRotationStream };
+import { a as RotationFileSizeUnit, c as RotationIntervalUnit, i as RotationFileSize, l as RotationOptions, n as RotatingFileStreamError, o as RotationGenerator, r as RotationCompressor, s as RotationInterval, t as RotatingFileStream, u as createRotationStream } from "../../log-rotation-_d7iRm9s.cjs";
+export { RotatingFileStream, RotatingFileStreamError, RotationCompressor, RotationFileSize, RotationFileSizeUnit, RotationGenerator, RotationInterval, RotationIntervalUnit, RotationOptions, createRotationStream };

package/dist/node/log/log-rotation.d.mts

@@ -0,0 +1,2 @@
+import { a as RotationFileSizeUnit, c as RotationIntervalUnit, i as RotationFileSize, l as RotationOptions, n as RotatingFileStreamError, o as RotationGenerator, r as RotationCompressor, s as RotationInterval, t as RotatingFileStream, u as createRotationStream } from "../../log-rotation-CkyjZbK5.mjs";
+export { RotatingFileStream, RotatingFileStreamError, RotationCompressor, RotationFileSize, RotationFileSizeUnit, RotationGenerator, RotationInterval, RotationIntervalUnit, RotationOptions, createRotationStream };

package/dist/node/log/log-rotation.mjs

@@ -0,0 +1,539 @@
+import process from "node:process";
+import { access, constants, createReadStream, createWriteStream } from "node:fs";
+import { sep } from "node:path";
+import { mkdir, open, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { exec } from "node:child_process";
+import { Writable } from "node:stream";
+import { setTimeout } from "node:timers";
+import { TextDecoder } from "node:util";
+import { createGzip } from "node:zlib";
+
+//#region src/node/log/log-rotation.ts
+async function exists(filename) {
+	return new Promise((resolve) => access(filename, constants.F_OK, (error) => resolve(!error)));
+}
+var RotatingFileStreamError = class extends Error {
+	code = "RFS-TOO-MANY";
+	constructor() {
+		super("Too many destination file attempts");
+	}
+};
+var RotatingFileStream = class extends Writable {
+	createGzip;
+	exec;
+	file;
+	filename;
+	finished;
+	fsCreateReadStream;
+	fsCreateWriteStream;
+	fsOpen;
+	fsReadFile;
+	fsStat;
+	fsUnlink;
+	generator;
+	last;
+	maxTimeout;
+	next;
+	options;
+	size;
+	stdout;
+	prev;
+	rotation;
+	initPromise;
+	timeout;
+	timeoutPromise;
+	constructor(generator, options) {
+		const { encoding, history, maxFiles, maxSize, path } = options;
+		super({
+			decodeStrings: true,
+			defaultEncoding: encoding
+		});
+		this.createGzip = createGzip;
+		this.exec = exec;
+		this.filename = (path || "") + generator(null);
+		this.fsCreateReadStream = createReadStream;
+		this.fsCreateWriteStream = createWriteStream;
+		this.fsOpen = open;
+		this.fsReadFile = readFile;
+		this.fsStat = stat;
+		this.fsUnlink = unlink;
+		this.generator = generator;
+		this.maxTimeout = 2147483640;
+		this.options = options;
+		this.stdout = process.stdout;
+		this.file = null;
+		this.initPromise = null;
+		this.timeout = null;
+		this.timeoutPromise = null;
+		this.prev = null;
+		this.next = null;
+		this.rotation = null;
+		this.last = "";
+		this.finished = false;
+		this.size = 0;
+		if (maxFiles || maxSize) options.history = (path || "") + (history || `${this.generator(null)}.txt`);
+		this.on("close", () => this.finished ? null : this.emit("finish"));
+		this.on("finish", () => this.finished = this.clear());
+		(async () => {
+			try {
+				this.initPromise = this.init();
+				await this.initPromise;
+				this.initPromise = null;
+			} catch (e) {}
+		})();
+	}
+	_destroy(error, callback) {
+		this.refinal(error, callback);
+	}
+	_final(callback) {
+		this.refinal(void 0, callback);
+	}
+	_write(chunk, encoding, callback) {
+		this.rewrite([{
+			chunk,
+			encoding
+		}], 0, callback);
+	}
+	_writev(chunks, callback) {
+		this.rewrite(chunks, 0, callback);
+	}
+	async refinal(error, callback) {
+		try {
+			this.clear();
+			if (this.initPromise) await this.initPromise;
+			if (this.timeoutPromise) await this.timeoutPromise;
+			await this.reclose();
+		} catch (e) {
+			return callback(error || e);
+		}
+		callback(error);
+	}
+	async rewrite(chunks, index, callback) {
+		const { size, teeToStdout } = this.options;
+		try {
+			if (this.initPromise) await this.initPromise;
+			for (let i = 0; i < chunks.length; ++i) {
+				const { chunk } = chunks[i];
+				this.size += chunk.length;
+				if (this.timeoutPromise) await this.timeoutPromise;
+				await this.file.write(chunk);
+				if (teeToStdout && !this.stdout.destroyed) this.stdout.write(chunk);
+				if (size && this.size >= size) await this.rotate();
+			}
+		} catch (e) {
+			return callback(e);
+		}
+		callback();
+	}
+	async init() {
+		const { immutable, initialRotation, interval, size } = this.options;
+		if (immutable) return new Promise((resolve, reject) => process.nextTick(() => this.immutate(true).then(resolve).catch((err) => reject(err))));
+		let stats;
+		try {
+			stats = await stat(this.filename);
+		} catch (e) {
+			if (e.code !== "ENOENT") throw e;
+			return this.reopen(0);
+		}
+		if (!stats.isFile()) throw new Error(`Can't write on: ${this.filename} (it is not a file)`);
+		if (initialRotation) {
+			this.intervalBounds(this.now());
+			const prev = this.prev;
+			this.intervalBounds(new Date(stats.mtime.getTime()));
+			if (prev !== this.prev) return this.rotate();
+		}
+		this.size = stats.size;
+		if (!size || stats.size < size) return this.reopen(stats.size);
+		if (interval) this.intervalBounds(this.now());
+		return this.rotate();
+	}
+	async makePath(name) {
+		await mkdir(name.split(sep).slice(0, -1).join(sep), { recursive: true });
+		return name;
+	}
+	async reopen(size) {
+		let file;
+		try {
+			file = await open(this.filename, "a", this.options.mode);
+		} catch (e) {
+			if (e.code !== "ENOENT") throw e;
+			await this.makePath(this.filename);
+			file = await open(this.filename, "a", this.options.mode);
+		}
+		this.file = file;
+		this.size = size;
+		this.interval();
+		this.emit("open", this.filename);
+	}
+	async reclose() {
+		const { file } = this;
+		if (!file) return;
+		this.file = null;
+		return file.close();
+	}
+	now() {
+		return /* @__PURE__ */ new Date();
+	}
+	async rotate() {
+		const { immutable, rotate } = this.options;
+		this.size = 0;
+		this.rotation = this.now();
+		this.clear();
+		this.emit("rotation");
+		await this.reclose();
+		if (rotate) return this.classical();
+		if (immutable) return this.immutate(false);
+		return this.move();
+	}
+	async findName() {
+		const { interval, path, intervalBoundary } = this.options;
+		for (let index = 1; index < 1e3; ++index) {
+			const filename = (path || "") + this.generator(interval && intervalBoundary ? new Date(this.prev) : this.rotation, index);
+			if (!await exists(filename)) return filename;
+		}
+		throw new RotatingFileStreamError();
+	}
+	async move() {
+		const { compress } = this.options;
+		const filename = await this.findName();
+		await this.touch(filename);
+		if (compress) await this.compress(filename);
+		else await rename(this.filename, filename);
+		return this.rotated(filename);
+	}
+	async touch(filename) {
+		let file;
+		try {
+			file = await this.fsOpen(filename, "a");
+		} catch (e) {
+			if (e.code !== "ENOENT") throw e;
+			await this.makePath(filename);
+			file = await open(filename, "a");
+		}
+		await file.close();
+		return this.unlink(filename);
+	}
+	async classical() {
+		const { compress, path, rotate = 0 } = this.options;
+		let rotatedName = "";
+		for (let count = rotate; count > 0; --count) {
+			const currName = path + this.generator(count);
+			const prevName = count === 1 ? this.filename : path + this.generator(count - 1);
+			if (!await exists(prevName)) continue;
+			if (!rotatedName) rotatedName = currName;
+			if (count === 1 && compress) await this.compress(currName);
+			else try {
+				await rename(prevName, currName);
+			} catch (e) {
+				if (e.code !== "ENOENT") throw e;
+				await this.makePath(currName);
+				await rename(prevName, currName);
+			}
+		}
+		return this.rotated(rotatedName);
+	}
+	clear() {
+		if (this.timeout) {
+			clearTimeout(this.timeout);
+			this.timeout = null;
+		}
+		return true;
+	}
+	intervalBoundsBig(now) {
+		const year = this.options.intervalUTC ? now.getUTCFullYear() : now.getFullYear();
+		let month = this.options.intervalUTC ? now.getUTCMonth() : now.getMonth();
+		let day = this.options.intervalUTC ? now.getUTCDate() : now.getDate();
+		let hours = this.options.intervalUTC ? now.getUTCHours() : now.getHours();
+		const { num, unit } = this.options.interval;
+		if (unit === "M") {
+			day = 1;
+			hours = 0;
+		} else if (unit === "d") hours = 0;
+		else hours = Number.parseInt(hours / num, 10) * num;
+		this.prev = new Date(year, month, day, hours, 0, 0, 0).getTime();
+		if (unit === "M") month += num;
+		else if (unit === "d") day += num;
+		else hours += num;
+		this.next = new Date(year, month, day, hours, 0, 0, 0).getTime();
+	}
+	intervalBounds(now) {
+		const unit = this.options.interval.unit;
+		if (unit === "M" || unit === "d" || unit === "h") this.intervalBoundsBig(now);
+		else {
+			let period = 1e3 * this.options.interval.num;
+			if (unit === "m") period *= 60;
+			this.prev = Number.parseInt(String(now.getTime() / period), 10) * period;
+			this.next = this.prev + period;
+		}
+		return new Date(this.prev);
+	}
+	interval() {
+		if (!this.options.interval) return;
+		this.intervalBounds(this.now());
+		const set = async () => {
+			const time = this.next - this.now().getTime();
+			if (time <= 0) try {
+				this.timeoutPromise = this.rotate();
+				await this.timeoutPromise;
+				this.timeoutPromise = null;
+			} catch (e) {}
+			else {
+				this.timeout = setTimeout(set, time > this.maxTimeout ? this.maxTimeout : time);
+				if (this.timeout && typeof this.timeout.unref === "function") this.timeout.unref();
+			}
+		};
+		set();
+	}
+	async compress(filename) {
+		const { compress } = this.options;
+		if (typeof compress === "function") await new Promise((resolve, reject) => {
+			this.exec(compress(this.filename, filename), (error, stdout, stderr) => {
+				this.emit("external", stdout, stderr);
+				error ? reject(error) : resolve();
+			});
+		});
+		else await this.gzip(filename);
+		return this.unlink(this.filename);
+	}
+	async gzip(filename) {
+		const { mode } = this.options;
+		const options = mode ? { mode } : {};
+		const inp = this.fsCreateReadStream(this.filename, {});
+		const out = this.fsCreateWriteStream(filename, options);
+		const zip = this.createGzip();
+		return new Promise((resolve, reject) => {
+			inp.once("error", reject);
+			out.once("error", reject);
+			zip.once("error", reject);
+			out.once("finish", resolve);
+			inp.pipe(zip).pipe(out);
+		});
+	}
+	async rotated(filename) {
+		const { maxFiles, maxSize } = this.options;
+		if (maxFiles || maxSize) await this.history(filename);
+		this.emit("rotated", filename);
+		return this.reopen(0);
+	}
+	async history(filename) {
+		const { history, maxFiles, maxSize } = this.options;
+		const res = [];
+		let files = [filename];
+		try {
+			if (history) files = [...(await this.fsReadFile(history, "utf8")).toString().split("\n"), filename];
+		} catch (e) {
+			if (e.code !== "ENOENT") throw e;
+		}
+		for (const file of files) if (file) try {
+			const stats = await this.fsStat(file);
+			if (stats.isFile()) res.push({
+				name: file,
+				size: stats.size,
+				time: stats.mtime.getTime()
+			});
+			else this.emit("warning", /* @__PURE__ */ new Error(`File '${file}' contained in history is not a regular file`));
+		} catch (e) {
+			if (e.code !== "ENOENT") throw e;
+		}
+		res.sort((a, b) => a.time - b.time);
+		if (maxFiles) while (res.length > maxFiles) {
+			const file = res.shift();
+			if (file) await this.unlink(file.name);
+			if (file) this.emit("removed", file.name, true);
+		}
+		if (maxSize) while (res.reduce((size, file) => size + file.size, 0) > maxSize) {
+			const file = res.shift();
+			if (file) await this.unlink(file.name);
+			if (file) this.emit("removed", file.name, false);
+		}
+		if (history) await writeFile(history, `${res.map((e) => e.name).join("\n")}\n`, "utf-8");
+		this.emit("history");
+	}
+	async immutate(first) {
+		const { size } = this.options;
+		const now = this.now();
+		for (let index = 1; index < 1e3; ++index) {
+			let fileSize = 0;
+			let stats;
+			this.filename = this.options.path + this.generator(now, index);
+			try {
+				stats = await this.fsStat(this.filename);
+			} catch (e) {
+				if (e.code !== "ENOENT") throw e;
+			}
+			if (stats) {
+				fileSize = stats.size;
+				if (!stats.isFile()) throw new Error(`Can't write on: '${this.filename}' (it is not a file)`);
+				if (size && fileSize >= size) continue;
+			}
+			if (first) {
+				this.last = this.filename;
+				return this.reopen(fileSize);
+			}
+			await this.rotated(this.last);
+			this.last = this.filename;
+			return;
+		}
+		throw new RotatingFileStreamError();
+	}
+	async unlink(filename) {
+		try {
+			await this.fsUnlink(filename);
+		} catch (e) {
+			if (e.code !== "ENOENT") throw e;
+			this.emit("warning", e);
+		}
+	}
+};
+function buildNumberCheck(field) {
+	return (type, options, value) => {
+		const converted = Number.parseInt(String(value), 10);
+		if (type !== "number" || Number.isNaN(converted) || converted <= 0) throw new Error(`'${field}' option must be a positive integer number`);
+	};
+}
+function buildStringCheck(field, check) {
+	return (type, options, value) => {
+		if (type !== "string") throw new Error(`Don't know how to handle 'options.${String(field)}' type: ${type}`);
+		options[field] = check(value);
+	};
+}
+function checkMeasure(value, what, units) {
+	const ret = {};
+	ret.num = Number.parseInt(value, 10);
+	if (Number.isNaN(ret.num)) throw new Error(`Unknown 'options.${what}' format: ${value}`);
+	if (ret.num <= 0) throw new Error(`A positive integer number is expected for 'options.${what}'`);
+	ret.unit = value.replace(/^[ 0]*/g, "").substr(`${ret.num}`.length, 1);
+	if (ret.unit.length === 0) throw new Error(`Missing unit for 'options.${what}'`);
+	if (!units[ret.unit]) throw new Error(`Unknown 'options.${what}' unit: ${ret.unit}`);
+	return ret;
+}
+const intervalUnits = {
+	M: true,
+	d: true,
+	h: true,
+	m: true,
+	s: true
+};
+function checkIntervalUnit(ret, unit, amount) {
+	if (Number.parseInt(amount / ret.num, 10) * ret.num !== amount) throw new Error(`An integer divider of ${amount} is expected as ${unit} for 'options.interval'`);
+}
+function checkInterval(value) {
+	const ret = checkMeasure(value, "interval", intervalUnits);
+	switch (ret.unit) {
+		case "h":
+			checkIntervalUnit(ret, "hours", 24);
+			break;
+		case "m":
+			checkIntervalUnit(ret, "minutes", 60);
+			break;
+		case "s":
+			checkIntervalUnit(ret, "seconds", 60);
+			break;
+	}
+	return ret;
+}
+const sizeUnits = {
+	B: true,
+	G: true,
+	K: true,
+	M: true
+};
+function checkSize(value) {
+	const ret = checkMeasure(value, "size", sizeUnits);
+	if (ret.unit === "K") return ret.num * 1024;
+	if (ret.unit === "M") return ret.num * 1048576;
+	if (ret.unit === "G") return ret.num * 1073741824;
+	return ret.num;
+}
+const checks = {
+	encoding: (type, options, value) => new TextDecoder(value),
+	immutable: () => {},
+	initialRotation: () => {},
+	interval: buildStringCheck("interval", checkInterval),
+	intervalBoundary: () => {},
+	intervalUTC: () => {},
+	maxFiles: buildNumberCheck("maxFiles"),
+	maxSize: buildStringCheck("maxSize", checkSize),
+	mode: () => {},
+	omitExtension: () => {},
+	rotate: buildNumberCheck("rotate"),
+	size: buildStringCheck("size", checkSize),
+	teeToStdout: () => {},
+	compress: (type, options, value) => {
+		if (value === false) return;
+		if (!value) throw new Error("A value for 'options.compress' must be specified");
+		if (type === "boolean") return options.compress = (source, dest) => `cat ${source} | gzip -c9 > ${dest}`;
+		if (type === "function") return;
+		if (type !== "string") throw new Error(`Don't know how to handle 'options.compress' type: ${type}`);
+		if (value !== "gzip") throw new Error(`Don't know how to handle compression method: ${value}`);
+	},
+	history: (type) => {
+		if (type !== "string") throw new Error(`Don't know how to handle 'options.history' type: ${type}`);
+	},
+	path: (type, options, value) => {
+		if (type !== "string") throw new Error(`Don't know how to handle 'options.path' type: ${type}`);
+		if (value.at(-1) !== sep) options.path = value + sep;
+	}
+};
+function checkOpts(options) {
+	const ret = {};
+	for (const k of Object.keys(options)) {
+		const opt = k;
+		const value = options[opt];
+		const type = typeof value;
+		ret[opt] = value;
+		if (!(opt in checks)) throw new Error(`Unknown option: ${opt}`);
+		checks[opt](type, ret, value);
+	}
+	if (!ret.path) ret.path = "";
+	if (!ret.interval) {
+		delete ret.immutable;
+		delete ret.initialRotation;
+		delete ret.intervalBoundary;
+		delete ret.intervalUTC;
+	}
+	if (ret.rotate) {
+		delete ret.history;
+		delete ret.immutable;
+		delete ret.maxFiles;
+		delete ret.maxSize;
+		delete ret.intervalBoundary;
+		delete ret.intervalUTC;
+	}
+	if (ret.immutable) delete ret.compress;
+	if (!ret.intervalBoundary) delete ret.initialRotation;
+	return ret;
+}
+function createClassical(filename, compress, omitExtension) {
+	return (time, index) => {
+		const idx = index || 0;
+		return idx ? `${filename}.${idx}${compress && !omitExtension ? ".gz" : ""}` : filename;
+	};
+}
+function createGenerator(filename, compress, omitExtension) {
+	const pad = (num) => (num > 9 ? "" : "0") + num;
+	return (time, index) => {
+		if (!time) return filename;
+		const t = typeof time === "number" ? new Date(time) : time;
+		const month = `${t.getFullYear()}${pad(t.getMonth() + 1)}`;
+		const day = pad(t.getDate());
+		const hour = pad(t.getHours());
+		const minute = pad(t.getMinutes());
+		return `${month + day}-${hour}${minute}-${pad(index || 0)}-${filename}${compress && !omitExtension ? ".gz" : ""}`;
+	};
+}
+function createRotationStream(filename, options) {
+	if (typeof options === "undefined") options = {};
+	else if (typeof options !== "object") throw new Error(`The "options" argument must be of type object. Received type ${typeof options}`);
+	const opts = checkOpts(options);
+	const { compress, omitExtension } = opts;
+	let generator;
+	if (typeof filename === "string") generator = opts.rotate ? createClassical(filename, !!compress, !!omitExtension) : createGenerator(filename, !!compress, !!omitExtension);
+	else if (typeof filename === "function") generator = filename;
+	else throw new Error(`The "filename" argument must be one of type string or function. Received type ${typeof filename}`);
+	return new RotatingFileStream(generator, opts);
+}
+
+//#endregion
+export { RotatingFileStream, RotatingFileStreamError, createRotationStream };
+//# sourceMappingURL=log-rotation.mjs.map