befly 3.76.0 → 3.76.2

package/libs/cron.js

@@ -0,0 +1,60 @@
+import { Logger } from "#befly/libs/logger/index.js";
+
+import { isPrimaryProcess } from "../utils/is.js";
+
+export function createCron(context) {
+    const jobs = new Map();
+
+    function register(name, schedule, task) {
+        if (!isPrimaryProcess()) return null;
+        if (jobs.has(name)) throw new Error(`定时任务 ${name} 重复注册`);
+
+        const job = Bun.cron(
+            schedule,
+            async () => {
+                Logger.info(`[定时任务] ${name} 开始执行`);
+                try {
+                    await task(context);
+                    Logger.info(`[定时任务] ${name} 执行完成`);
+                } catch (error) {
+                    Logger.error(`[定时任务] ${name} 执行失败`, error);
+                }
+            },
+            context.config.tz ? { tz: context.config.tz } : undefined
+        );
+        jobs.set(name, job);
+        return job;
+    }
+
+    function second(name, seconds, task) {
+        if (!isPrimaryProcess()) return null;
+        if (jobs.has(name)) throw new Error(`定时任务 ${name} 重复注册`);
+
+        let running = false;
+        const timer = setInterval(async () => {
+            if (running) return;
+            running = true;
+            try {
+                await task(context);
+            } catch (error) {
+                Logger.error(`[定时任务] ${name} 执行失败`, error);
+            } finally {
+                running = false;
+            }
+        }, seconds * 1000);
+        const job = { stop: () => clearInterval(timer) };
+        jobs.set(name, job);
+        return job;
+    }
+
+    function stopAll() {
+        for (const job of jobs.values()) job.stop();
+        jobs.clear();
+    }
+
+    return { register: register, second: second, stopAll: stopAll };
+}
+
+export function registerCorns(context, corns) {
+    for (const corn of corns) context.cron.register(corn.fileName, corn.schedule, corn.handler);
+}

package/libs/logger/index.js

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

package/libs/logger/logger.js

@@ -0,0 +1,245 @@
+import { createWriteStream, existsSync, mkdirSync, rmSync } from "node:fs";
+import { resolve } from "node:path";
+
+import { buildSensitiveKeyMatcher, isPlainObject, sanitizeLogRecord } from "./sanitize.js";
+
+const builtinSensitiveKeys = ["*password*", "pass", "pwd", "*token*", "access_token", "refresh_token", "accessToken", "refreshToken", "authorization", "cookie", "set-cookie", "*secret*", "apiKey", "api_key", "privateKey", "private_key"];
+const textEncoder = new TextEncoder();
+
+let config;
+let sanitizeOptions;
+let mockInstance = null;
+let appSink = null;
+let errorSink = null;
+
+function normalizeInteger(value, fallback, min, max) {
+    if (!Number.isInteger(value)) return fallback;
+    return Math.min(max, Math.max(min, value));
+}
+
+function formatTime(value, dateOnly = false) {
+    const date = new Date(value);
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    if (dateOnly) return `${year}-${month}-${day}`;
+    const hour = String(date.getHours()).padStart(2, "0");
+    const minute = String(date.getMinutes()).padStart(2, "0");
+    const second = String(date.getSeconds()).padStart(2, "0");
+    return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
+}
+
+function writeStderr(message) {
+    Bun.stderr.write(`[befly-logger] ${message}\n`);
+}
+
+class FileSink {
+    constructor(prefix, sinkConfig) {
+        this.prefix = prefix;
+        this.config = sinkConfig;
+        this.stream = null;
+        this.date = "";
+        this.index = 0;
+        this.size = 0;
+        this.pending = Promise.resolve();
+        this.disabled = false;
+    }
+
+    getPath(date, index) {
+        if (this.prefix === "dev") return resolve(this.config.dir, "dev.log");
+        const instance = this.config.instanceId ? `.${this.config.instanceId}` : "";
+        const sequence = index > 0 ? `.${index}` : "";
+        const name = this.prefix === "app" ? `${date}${instance}${sequence}.log` : `${this.prefix}.${date}${instance}${sequence}.log`;
+        return resolve(this.config.dir, name);
+    }
+
+    open(path) {
+        this.stream = createWriteStream(path, { flags: "a" });
+        this.stream.on("error", (error) => {
+            this.disabled = true;
+            writeStderr(`写入失败 (${this.prefix}): ${error.message || error}`);
+        });
+    }
+
+    close(resetPosition = true) {
+        const stream = this.stream;
+        this.stream = null;
+        if (resetPosition) {
+            this.date = "";
+            this.index = 0;
+            this.size = 0;
+        }
+        if (!stream) return Promise.resolve();
+        return new Promise((resolveClose) => {
+            stream.end(resolveClose);
+        });
+    }
+
+    async prepare(bytes) {
+        const date = formatTime(Date.now(), true);
+        if (this.stream && this.date !== date) await this.close();
+
+        if (!this.stream) {
+            this.date = date;
+            this.index = 0;
+            let path = this.getPath(date, this.index);
+            this.size = Bun.file(path).size;
+            while (this.prefix !== "dev" && this.size > 0 && this.size + bytes > this.config.maxBytes) {
+                this.index += 1;
+                path = this.getPath(date, this.index);
+                this.size = Bun.file(path).size;
+            }
+            this.open(path);
+        }
+
+        if (this.prefix !== "dev" && this.size > 0 && this.size + bytes > this.config.maxBytes) {
+            await this.close(false);
+            this.index += 1;
+            this.size = Bun.file(this.getPath(date, this.index)).size;
+            this.open(this.getPath(date, this.index));
+        }
+    }
+
+    write(line) {
+        if (this.disabled) return;
+        const bytes = textEncoder.encode(line).byteLength;
+        this.pending = this.pending.then(async () => {
+            await this.prepare(bytes);
+            if (!this.stream || this.disabled) return;
+            this.size += bytes;
+            await new Promise((resolveWrite) => {
+                this.stream.write(line, resolveWrite);
+            });
+        });
+    }
+
+    async flush() {
+        await this.pending;
+    }
+
+    async shutdown() {
+        await this.pending;
+        await this.close();
+    }
+}
+
+function resetConfig(options = {}) {
+    const runtimeEnv = options.runtimeEnv === "development" ? "development" : "production";
+    const dir = options.dir ? resolve(options.dir) : resolve(process.cwd(), "logs");
+    const maxSize = normalizeInteger(options.maxSize, 20, 10, 100);
+
+    config = {
+        debug: options.debug ?? 0,
+        dir: dir,
+        runtimeEnv: runtimeEnv,
+        instanceId: Bun.env.BM2_INSTANCE_ID || Bun.env.BM2_APP_INSTANCE || "",
+        maxBytes: maxSize * 1024 * 1024
+    };
+
+    sanitizeOptions = {
+        sanitizeDepth: normalizeInteger(options.sanitizeDepth, 5, 1, 10),
+        sanitizeNodes: normalizeInteger(options.sanitizeNodes, 5000, 50, 20000),
+        sanitizeObjectKeys: normalizeInteger(options.sanitizeObjectKeys, 500, 10, 5000),
+        sensitiveKeyMatcher: buildSensitiveKeyMatcher(builtinSensitiveKeys, options.excludeFields)
+    };
+}
+
+function prepareDirectory(clearDevelopmentLog) {
+    mkdirSync(config.dir, { recursive: true });
+    if (clearDevelopmentLog && config.runtimeEnv === "development") {
+        const path = resolve(config.dir, "dev.log");
+        if (existsSync(path)) rmSync(path, { force: true });
+    }
+}
+
+function getSink(level) {
+    prepareDirectory(false);
+    if (config.runtimeEnv === "development") {
+        if (!appSink) appSink = new FileSink("dev", config);
+        return appSink;
+    }
+    if (level === "error") {
+        if (!errorSink) errorSink = new FileSink("error", config);
+        return errorSink;
+    }
+    if (!appSink) appSink = new FileSink("app", config);
+    return appSink;
+}
+
+function toRecord(input) {
+    if (isPlainObject(input)) return input;
+    if (input instanceof Error) return { msg: input.message || input.name || "Error", err: input };
+    if (input === undefined) return { msg: "" };
+    if (input === null) return { msg: "null" };
+    if (typeof input === "object") return { value: input };
+    try {
+        return { msg: String(input) };
+    } catch {
+        return { msg: "[Unserializable]" };
+    }
+}
+
+function buildLine(level, record) {
+    const output = {
+        level: level,
+        time: formatTime(Date.now()),
+        pid: process.pid
+    };
+    for (const [key, value] of Object.entries(record)) {
+        if (!["level", "time", "pid"].includes(key)) output[key] = value;
+    }
+    if (output.msg === undefined) output.msg = "";
+    try {
+        return `${JSON.stringify(output)}\n`;
+    } catch {
+        return `${JSON.stringify({ level: level, time: output.time, pid: process.pid, msg: "[Unserializable log record]" })}\n`;
+    }
+}
+
+function write(level, input) {
+    if (level === "debug" && config.debug !== 1 && config.debug !== true) return;
+    const record = sanitizeLogRecord(toRecord(input), sanitizeOptions);
+    if (mockInstance) {
+        mockInstance[level](record);
+        return;
+    }
+    getSink(level).write(buildLine(level, record));
+}
+
+function createMethod(level) {
+    return function (message, data) {
+        write(level, isPlainObject(message) ? message : { msg: message, data: data });
+    };
+}
+
+resetConfig();
+
+export const Logger = {
+    info: createMethod("info"),
+    warn: createMethod("warn"),
+    error: function (message, error, data) {
+        write("error", isPlainObject(message) ? message : { msg: message, err: error, data: data });
+    },
+    debug: createMethod("debug"),
+    configure: function (options = {}) {
+        const sinks = [appSink, errorSink].filter(Boolean);
+        appSink = null;
+        errorSink = null;
+        for (const sink of sinks) sink.shutdown().catch((error) => writeStderr(`关闭失败: ${error.message || error}`));
+        resetConfig(options);
+        prepareDirectory(true);
+    },
+    setMock: function (mock) {
+        mockInstance = mock;
+    },
+    flush: async function () {
+        if (mockInstance) return;
+        await Promise.all([appSink?.flush(), errorSink?.flush()]);
+    },
+    shutdown: async function () {
+        const sinks = [appSink, errorSink].filter(Boolean);
+        appSink = null;
+        errorSink = null;
+        await Promise.all(sinks.map((sink) => sink.shutdown()));
+    }
+};

package/libs/logger/sanitize.js

@@ -0,0 +1,115 @@
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null) return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+
+function errorChainSummary(error) {
+    const parts = [];
+    const visited = new Set();
+    let current = error;
+
+    while (current instanceof Error && !visited.has(current)) {
+        visited.add(current);
+        const meta = [current.code, current.subsystem, current.operation].filter(Boolean).join("/");
+        const text = current.message || current.name || "Error";
+        parts.push(meta ? `${text} [${meta}]` : text);
+        current = current.cause;
+    }
+
+    return parts.join(" <- ");
+}
+
+export function buildSensitiveKeyMatcher(builtinPatterns, userPatterns) {
+    const exactSet = new Set();
+    const contains = [];
+
+    for (const item of [...builtinPatterns, ...(Array.isArray(userPatterns) ? userPatterns : [])]) {
+        const pattern = String(item).trim().toLowerCase();
+        if (!pattern) continue;
+        if (!pattern.includes("*")) {
+            exactSet.add(pattern);
+            continue;
+        }
+        const core = pattern.replace(/\*+/g, "").trim();
+        if (core) contains.push(core);
+    }
+
+    return { exactSet: exactSet, contains: contains };
+}
+
+function isSensitiveKey(key, matcher) {
+    const lower = String(key).toLowerCase();
+    if (matcher.exactSet.has(lower)) return true;
+    return matcher.contains.some((part) => lower.includes(part));
+}
+
+function sanitizeError(error, options, state, depth, visited) {
+    if (visited.has(error)) return "[Circular]";
+    visited.add(error);
+
+    const output = {
+        name: error.name || "Error",
+        message: error.message || "",
+        chain: errorChainSummary(error)
+    };
+
+    if (typeof error.stack === "string") output.stack = error.stack;
+    if (error.cause !== undefined) output.cause = sanitizeValue(error.cause, options, state, depth + 1, visited);
+
+    for (const key of Object.keys(error)) {
+        if (["name", "message", "stack", "cause"].includes(key)) continue;
+        output[key] = isSensitiveKey(key, options.sensitiveKeyMatcher) ? "[MASKED]" : sanitizeValue(error[key], options, state, depth + 1, visited);
+    }
+
+    return output;
+}
+
+function stringifyPreview(value, options) {
+    const seen = new WeakSet();
+    try {
+        return JSON.stringify(value, (key, item) => {
+            if (key && isSensitiveKey(key, options.sensitiveKeyMatcher)) return "[MASKED]";
+            if (typeof item === "bigint") return String(item);
+            if (item && typeof item === "object") {
+                if (seen.has(item)) return "[Circular]";
+                seen.add(item);
+            }
+            return item;
+        });
+    } catch {
+        try {
+            return String(value);
+        } catch {
+            return "[Unserializable]";
+        }
+    }
+}
+
+function sanitizeValue(value, options, state, depth, visited) {
+    if (value === null || value === undefined || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+    if (typeof value === "bigint") return String(value);
+    if (value instanceof Error) return sanitizeError(value, options, state, depth, visited);
+
+    if (!Array.isArray(value) && !isPlainObject(value)) return stringifyPreview(value, options);
+    if (visited.has(value)) return "[Circular]";
+    if (depth >= options.sanitizeDepth || state.nodes >= options.sanitizeNodes) return stringifyPreview(value, options);
+
+    visited.add(value);
+    state.nodes += 1;
+
+    if (Array.isArray(value)) return value.map((item) => sanitizeValue(item, options, state, depth + 1, visited));
+
+    const output = {};
+    const entries = Object.entries(value).slice(0, options.sanitizeObjectKeys);
+    for (const [key, item] of entries) {
+        output[key] = isSensitiveKey(key, options.sensitiveKeyMatcher) ? "[MASKED]" : sanitizeValue(item, options, state, depth + 1, visited);
+    }
+    return output;
+}
+
+export function sanitizeLogRecord(record, options) {
+    return sanitizeValue(record, options, { nodes: 0 }, 0, new WeakSet());
+}
+
+export { isPlainObject };