@flink-app/flink 0.14.3 → 2.0.0-alpha.100

package/dist/src/FlinkLogFactory.js

@@ -0,0 +1,619 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlinkLogFactory = exports.ComponentLogger = void 0;
+var node_color_log_1 = __importDefault(require("node-color-log"));
+var LOG_LEVELS = {
+    trace: 0,
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4,
+};
+/**
+ * Component-specific logger with independent log level control
+ */
+var ComponentLogger = /** @class */ (function () {
+    function ComponentLogger(componentName) {
+        this.componentLevel = null;
+        this.componentName = componentName;
+        this.namedLogger = node_color_log_1.default.createNamedLogger(componentName);
+    }
+    /**
+     * Set log level for this specific component.
+     * Overrides the global log level.
+     */
+    ComponentLogger.prototype.setLevel = function (level) {
+        this.componentLevel = level;
+    };
+    /**
+     * Clear component-specific level and fall back to global level
+     */
+    ComponentLogger.prototype.clearLevel = function () {
+        this.componentLevel = null;
+    };
+    /**
+     * Check if a message should be logged based on component and global levels
+     */
+    ComponentLogger.prototype.shouldLog = function (messageLevel) {
+        var _a;
+        var effectiveLevel = (_a = this.componentLevel) !== null && _a !== void 0 ? _a : FlinkLogFactory.getGlobalLevel();
+        return LOG_LEVELS[messageLevel] >= LOG_LEVELS[effectiveLevel];
+    };
+    ComponentLogger.prototype.trace = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.shouldLog("trace")) {
+            // node-color-log doesn't support trace, use console.log for stdout
+            if (FlinkLogFactory.getShowTimestamps()) {
+                var timestamp = new Date().toISOString();
+                console.log.apply(console, __spreadArray(["".concat(timestamp, " [").concat(this.componentName, "] [TRACE]")], args, false));
+            }
+            else {
+                console.log.apply(console, __spreadArray(["[".concat(this.componentName, "] [TRACE]")], args, false));
+            }
+        }
+    };
+    ComponentLogger.prototype.debug = function () {
+        var _a;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.shouldLog("debug")) {
+            (_a = this.namedLogger).debug.apply(_a, args);
+        }
+    };
+    ComponentLogger.prototype.info = function () {
+        var _a;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.shouldLog("info")) {
+            (_a = this.namedLogger).info.apply(_a, args);
+        }
+    };
+    ComponentLogger.prototype.warn = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.shouldLog("warn")) {
+            // Use console.warn to write to stderr (Unix/POSIX best practice)
+            if (FlinkLogFactory.getShowTimestamps()) {
+                var timestamp = new Date().toISOString();
+                console.warn.apply(console, __spreadArray(["".concat(timestamp, " [").concat(this.componentName, "] [WARN]")], args, false));
+            }
+            else {
+                console.warn.apply(console, __spreadArray(["[".concat(this.componentName, "] [WARN]")], args, false));
+            }
+        }
+    };
+    ComponentLogger.prototype.error = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.shouldLog("error")) {
+            // Use console.error to write to stderr (Unix/POSIX best practice)
+            if (FlinkLogFactory.getShowTimestamps()) {
+                var timestamp = new Date().toISOString();
+                console.error.apply(console, __spreadArray(["".concat(timestamp, " [").concat(this.componentName, "] [ERROR]")], args, false));
+            }
+            else {
+                console.error.apply(console, __spreadArray(["[".concat(this.componentName, "] [ERROR]")], args, false));
+            }
+        }
+    };
+    ComponentLogger.prototype.json = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        if (this.shouldLog("debug")) {
+            for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {
+                var o = args_1[_a];
+                console.log(JSON.stringify(o, null, 2));
+            }
+        }
+    };
+    ComponentLogger.prototype.bgColorLog = function (color) {
+        var _a;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        if (this.shouldLog("debug")) {
+            (_a = this.namedLogger).bgColorLog.apply(_a, __spreadArray([color], args, false));
+        }
+    };
+    ComponentLogger.prototype.fontColorLog = function (color) {
+        var _a;
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        if (this.shouldLog("info")) {
+            (_a = this.namedLogger).fontColorLog.apply(_a, __spreadArray([color], args, false));
+        }
+    };
+    return ComponentLogger;
+}());
+exports.ComponentLogger = ComponentLogger;
+/**
+ * Factory for creating component-specific loggers with hierarchical level control
+ */
+var FlinkLogFactory = /** @class */ (function () {
+    function FlinkLogFactory() {
+    }
+    /**
+     * Set the global log level (affects all loggers without component-specific levels)
+     */
+    FlinkLogFactory.setGlobalLevel = function (level) {
+        FlinkLogFactory.globalLevel = level;
+        // node-color-log doesn't support trace, so use debug as the effective level
+        var effectiveLevel = level === "trace" ? "debug" : level;
+        node_color_log_1.default.setLevel(effectiveLevel);
+    };
+    /**
+     * Get the current global log level
+     */
+    FlinkLogFactory.getGlobalLevel = function () {
+        return FlinkLogFactory.globalLevel;
+    };
+    /**
+     * Get all registered loggers (useful for debugging)
+     */
+    FlinkLogFactory.getLoggers = function () {
+        return FlinkLogFactory.loggers;
+    };
+    /**
+     * Enable or disable timestamps in log messages
+     */
+    FlinkLogFactory.setShowTimestamps = function (show) {
+        FlinkLogFactory.showTimestamps = show;
+    };
+    /**
+     * Check if timestamps are enabled
+     */
+    FlinkLogFactory.getShowTimestamps = function () {
+        return FlinkLogFactory.showTimestamps;
+    };
+    /**
+     * Clear all component-specific log levels (fall back to global)
+     */
+    FlinkLogFactory.resetComponentLevels = function () {
+        FlinkLogFactory.componentConfigs = {};
+        for (var _i = 0, _a = Array.from(FlinkLogFactory.loggers.values()); _i < _a.length; _i++) {
+            var logger = _a[_i];
+            logger.clearLevel();
+        }
+    };
+    /**
+     * Clear all hierarchical prefix configurations
+     */
+    FlinkLogFactory.resetHierarchicalLevels = function () {
+        FlinkLogFactory.hierarchicalConfigs = [];
+    };
+    /**
+     * Clear all wildcard pattern configurations
+     */
+    FlinkLogFactory.resetWildcardLevels = function () {
+        FlinkLogFactory.wildcardConfigs = [];
+    };
+    /**
+     * Set log level for a specific component by name (exact match)
+     */
+    FlinkLogFactory.setComponentLevel = function (componentName, level) {
+        var normalized = FlinkLogFactory.normalize(componentName);
+        if (level === null) {
+            // Remove exact match configuration
+            delete FlinkLogFactory.componentConfigs[normalized];
+            var logger = FlinkLogFactory.loggers.get(normalized);
+            if (logger) {
+                logger.clearLevel();
+            }
+        }
+        else {
+            // Set exact match configuration
+            FlinkLogFactory.componentConfigs[normalized] = level;
+            var logger = FlinkLogFactory.loggers.get(normalized);
+            if (logger) {
+                logger.setLevel(level);
+            }
+        }
+    };
+    /**
+     * Set hierarchical prefix-based log level (Java-style)
+     * @param prefix Logger name prefix (e.g., "flink.ai" matches all "flink.ai.*")
+     * @param level Log level to apply
+     *
+     * @example
+     * FlinkLogFactory.setHierarchicalLevel("flink.ai", "debug");
+     * // Now all loggers starting with "flink.ai." will use debug level
+     * // This includes the exact match "flink.ai" AND all children "flink.ai.*"
+     */
+    FlinkLogFactory.setHierarchicalLevel = function (prefix, level) {
+        var normalized = FlinkLogFactory.normalize(prefix);
+        // Ensure prefix ends with dot for consistent matching
+        var prefixWithDot = normalized.endsWith(".") ? normalized : normalized + ".";
+        var specificity = FlinkLogFactory.calculatePrefixSpecificity(normalized);
+        // Remove existing config for this prefix if it exists
+        FlinkLogFactory.hierarchicalConfigs = FlinkLogFactory.hierarchicalConfigs.filter(function (c) { return c.prefix !== prefixWithDot; });
+        // Add new config
+        FlinkLogFactory.hierarchicalConfigs.push({
+            prefix: prefixWithDot,
+            level: level,
+            specificity: specificity,
+        });
+        // Also set exact match for the prefix itself (without trailing dot)
+        // This ensures "flink.ai.openai" matches when using setHierarchicalLevel("flink.ai.openai", "debug")
+        FlinkLogFactory.componentConfigs[normalized] = level;
+        // Sort by specificity (most specific first) for efficient matching
+        FlinkLogFactory.hierarchicalConfigs.sort(function (a, b) { return b.specificity - a.specificity; });
+    };
+    /**
+     * Set wildcard pattern-based log level (advanced)
+     * @param pattern Wildcard pattern (e.g., "flink.ai.*" or "flink.ai.**")
+     * @param level Log level to apply
+     *
+     * @example
+     * FlinkLogFactory.setWildcardLevel("flink.ai.*", "debug");
+     * // Matches flink.ai.openai but NOT flink.ai.openai.v4
+     *
+     * FlinkLogFactory.setWildcardLevel("flink.ai.**", "trace");
+     * // Matches any depth under flink.ai.
+     */
+    FlinkLogFactory.setWildcardLevel = function (pattern, level) {
+        var normalized = FlinkLogFactory.normalize(pattern);
+        var specificity = FlinkLogFactory.calculateWildcardSpecificity(normalized);
+        // Remove existing config for this pattern if it exists
+        FlinkLogFactory.wildcardConfigs = FlinkLogFactory.wildcardConfigs.filter(function (c) { return c.pattern !== normalized; });
+        // Add new config
+        FlinkLogFactory.wildcardConfigs.push({
+            pattern: normalized,
+            level: level,
+            specificity: specificity,
+        });
+        // Sort by specificity (most specific first) for efficient matching
+        FlinkLogFactory.wildcardConfigs.sort(function (a, b) { return b.specificity - a.specificity; });
+    };
+    /**
+     * Get the effective log level for a component (resolved through hierarchy)
+     * @param componentName Component name to check
+     * @returns Resolved log level or null if only global level applies
+     */
+    FlinkLogFactory.getEffectiveLevel = function (componentName) {
+        return FlinkLogFactory.resolveComponentLevel(componentName);
+    };
+    /**
+     * Initialize logging from environment variables and/or configuration file
+     *
+     * Priority (highest to lowest):
+     * 1. Config file (flink.config.js)
+     * 2. Environment variable (LOG_LEVEL=debug)
+     *
+     * @param fileConfig Optional logging configuration from flink.config.js
+     *
+     * @example Environment Variable
+     * ```bash
+     * LOG_LEVEL=debug pnpm run dev
+     * ```
+     *
+     * @example Config File (flink.config.js)
+     * ```javascript
+     * module.exports = {
+     *   logging: {
+     *     global: "info",
+     *     showTimestamps: true,
+     *     components: {
+     *       "flink.ai.openai": "trace",          // exact match
+     *       "flink.ai.*": "debug",               // single-level wildcard
+     *       "flink.database.**": "warn",         // multi-level wildcard
+     *       "flink.handlers.": "info"            // prefix match
+     *     }
+     *   }
+     * };
+     * ```
+     */
+    FlinkLogFactory.configure = function (fileConfig) {
+        var _a;
+        if (FlinkLogFactory.initialized) {
+            return;
+        }
+        // 1. Parse environment variables (lowest priority)
+        var envConfig = FlinkLogFactory.parseEnvironment();
+        // 2. Parse file config components map (highest priority)
+        var fileComponentsParsed = { exact: {}, hierarchical: [], wildcards: [] };
+        if (fileConfig === null || fileConfig === void 0 ? void 0 : fileConfig.components) {
+            fileComponentsParsed = FlinkLogFactory.parseComponentsMap(fileConfig.components);
+        }
+        // 3. Merge configurations
+        var finalConfig = {
+            global: (fileConfig === null || fileConfig === void 0 ? void 0 : fileConfig.global) || envConfig.global || "info",
+            showTimestamps: (_a = fileConfig === null || fileConfig === void 0 ? void 0 : fileConfig.showTimestamps) !== null && _a !== void 0 ? _a : true, // default: true
+            exact: __assign({}, fileComponentsParsed.exact),
+            hierarchical: __spreadArray([], fileComponentsParsed.hierarchical, true),
+            wildcards: __spreadArray([], fileComponentsParsed.wildcards, true),
+        };
+        // 4. Apply global level
+        FlinkLogFactory.setGlobalLevel(finalConfig.global);
+        // 5. Apply timestamp setting
+        FlinkLogFactory.setShowTimestamps(finalConfig.showTimestamps);
+        // 6. Store exact component configs
+        FlinkLogFactory.componentConfigs = finalConfig.exact;
+        // 7. Store hierarchical configs (sorted by specificity)
+        FlinkLogFactory.hierarchicalConfigs = finalConfig.hierarchical.sort(function (a, b) { return b.specificity - a.specificity; });
+        // 8. Store wildcard configs (sorted by specificity)
+        FlinkLogFactory.wildcardConfigs = finalConfig.wildcards.sort(function (a, b) { return b.specificity - a.specificity; });
+        FlinkLogFactory.initialized = true;
+    };
+    /**
+     * Parse logging configuration from environment variables
+     * Supports only LOG_LEVEL for global level setting
+     */
+    FlinkLogFactory.parseEnvironment = function () {
+        var config = {};
+        if (process.env.LOG_LEVEL) {
+            var level = process.env.LOG_LEVEL.toLowerCase();
+            if (FlinkLogFactory.isValidLogLevel(level)) {
+                config.global = level;
+            }
+        }
+        return config;
+    };
+    /**
+     * Normalize logger name to lowercase (Java-style convention)
+     * @param name Logger name or pattern
+     * @returns Normalized lowercase name
+     */
+    FlinkLogFactory.normalize = function (name) {
+        return name.toLowerCase();
+    };
+    /**
+     * Determine if a name should be treated as a hierarchical prefix
+     * @param name Normalized logger name
+     * @returns True if it should be treated as a prefix
+     */
+    FlinkLogFactory.shouldTreatAsPrefix = function (name) {
+        // Default: if name contains dots, treat as hierarchical prefix
+        // This covers the common case where "flink.ai" should match "flink.ai.*"
+        return name.includes(".");
+    };
+    /**
+     * Calculate specificity for prefix matching
+     * More specific prefixes (more segments) have higher specificity
+     * @param prefix Prefix string (may or may not end with dot)
+     * @returns Specificity score (number of segments)
+     */
+    FlinkLogFactory.calculatePrefixSpecificity = function (prefix) {
+        // Remove trailing dot if present
+        var normalized = prefix.endsWith(".") ? prefix.slice(0, -1) : prefix;
+        // Count dot-separated segments
+        return normalized.split(".").filter(function (s) { return s.length > 0; }).length;
+    };
+    /**
+     * Calculate specificity for wildcard patterns
+     * More specific patterns (more non-wildcard segments) have higher specificity
+     * For same segment count, * (single-level) is more specific than ** (multi-level)
+     * @param pattern Wildcard pattern
+     * @returns Specificity score (base + decimal for wildcard type)
+     */
+    FlinkLogFactory.calculateWildcardSpecificity = function (pattern) {
+        var segments = pattern.split(".");
+        var nonWildcardCount = segments.filter(function (seg) { return seg !== "*" && seg !== "**" && seg.length > 0; }).length;
+        // Base specificity: number of non-wildcard segments
+        var specificity = nonWildcardCount * 10;
+        // Add fractional specificity based on wildcard type
+        // * (single-level) = more specific than ** (multi-level)
+        if (pattern.includes("*")) {
+            if (pattern.includes("**")) {
+                specificity += 1; // ** is less specific
+            }
+            else {
+                specificity += 5; // * is more specific
+            }
+        }
+        return specificity;
+    };
+    /**
+     * Resolve component log level through hierarchical matching
+     * Order of precedence (highest to lowest):
+     * 1. Exact match
+     * 2. Most specific prefix match
+     * 3. Less specific prefix match
+     * 4. Wildcard pattern match
+     * 5. null (falls back to global level)
+     *
+     * @param componentName Component name to resolve
+     * @returns Resolved log level or null
+     */
+    FlinkLogFactory.resolveComponentLevel = function (componentName) {
+        var normalized = FlinkLogFactory.normalize(componentName);
+        // 1. Try exact match first (O(1) - fastest, highest priority)
+        if (FlinkLogFactory.componentConfigs[normalized]) {
+            return FlinkLogFactory.componentConfigs[normalized];
+        }
+        // 2. Try hierarchical prefix matches (O(n) where n = number of prefixes)
+        // Already sorted by specificity (most specific first)
+        for (var _i = 0, _a = FlinkLogFactory.hierarchicalConfigs; _i < _a.length; _i++) {
+            var config = _a[_i];
+            if (normalized.startsWith(config.prefix)) {
+                return config.level;
+            }
+        }
+        // 3. Try wildcard patterns (O(n) where n = number of patterns)
+        // Already sorted by specificity (most specific first)
+        for (var _b = 0, _c = FlinkLogFactory.wildcardConfigs; _b < _c.length; _b++) {
+            var config = _c[_b];
+            if (FlinkLogFactory.matchWildcard(normalized, config.pattern)) {
+                return config.level;
+            }
+        }
+        // 4. No match - fall back to global level
+        return null;
+    };
+    /**
+     * Simple wildcard matching for logger patterns
+     * Supports:
+     * - * matches single segment (flink.ai.* matches flink.ai.openai)
+     * - ** matches any depth (flink.ai.** matches flink.ai.openai.v4)
+     * - Partial segment match (flink.ai.open* matches flink.ai.openai)
+     *
+     * @param name Logger name to match
+     * @param pattern Wildcard pattern
+     * @returns True if pattern matches
+     */
+    FlinkLogFactory.matchWildcard = function (name, pattern) {
+        // Special handling for ** (multi-level wildcard)
+        // Need to process dots BEFORE replacing **
+        // Step 1: Escape dots first (before any other processing)
+        var regexPattern = pattern.replace(/\./g, "\\.");
+        // Step 2: Replace ** with placeholder (matches anything including dots)
+        regexPattern = regexPattern.replace(/\*\*/g, "___DOUBLE_STAR___");
+        // Step 3: Replace single * with single-segment match (non-dot chars)
+        regexPattern = regexPattern.replace(/\*/g, "[^\\.]+");
+        // Step 4: Replace ** placeholder with multi-segment match
+        regexPattern = regexPattern.replace(/___DOUBLE_STAR___/g, ".*");
+        var regex = new RegExp("^".concat(regexPattern, "$"));
+        return regex.test(name);
+    };
+    /**
+     * Parse components map and classify entries into exact, prefix, or wildcard matches
+     * @param components Components map from config
+     * @returns Classified configuration
+     */
+    FlinkLogFactory.parseComponentsMap = function (components) {
+        var exact = {};
+        var hierarchical = [];
+        var wildcards = [];
+        for (var _i = 0, _a = Object.entries(components); _i < _a.length; _i++) {
+            var _b = _a[_i], key = _b[0], level = _b[1];
+            var normalized = FlinkLogFactory.normalize(key);
+            if (normalized.includes("*")) {
+                // Wildcard pattern (e.g., "flink.ai.*" or "flink.ai.**")
+                wildcards.push({
+                    pattern: normalized,
+                    level: level,
+                    specificity: FlinkLogFactory.calculateWildcardSpecificity(normalized),
+                });
+            }
+            else if (normalized.endsWith(".")) {
+                // Prefix match (e.g., "flink.ai.")
+                hierarchical.push({
+                    prefix: normalized,
+                    level: level,
+                    specificity: FlinkLogFactory.calculatePrefixSpecificity(normalized),
+                });
+            }
+            else if (normalized.includes(".")) {
+                // Ambiguous: could be exact or prefix
+                // Store as BOTH exact and hierarchical
+                exact[normalized] = level;
+                hierarchical.push({
+                    prefix: normalized + ".",
+                    level: level,
+                    specificity: FlinkLogFactory.calculatePrefixSpecificity(normalized),
+                });
+            }
+            else {
+                // Simple name (no dots) - exact match only
+                exact[normalized] = level;
+            }
+        }
+        // Sort by specificity (most specific first)
+        hierarchical.sort(function (a, b) { return b.specificity - a.specificity; });
+        wildcards.sort(function (a, b) { return b.specificity - a.specificity; });
+        return { exact: exact, hierarchical: hierarchical, wildcards: wildcards };
+    };
+    /**
+     * Check if a string is a valid log level
+     */
+    FlinkLogFactory.isValidLogLevel = function (level) {
+        return ["trace", "debug", "info", "warn", "error"].includes(level);
+    };
+    /**
+     * Create or retrieve a component-specific logger
+     * Automatically applies environment/config settings when logger is created
+     * Supports hierarchical prefix matching (Java-style)
+     *
+     * @param componentName Logger name (lowercase dot notation recommended, e.g., "flink.ai.openai")
+     * @returns ComponentLogger instance
+     *
+     * @example
+     * ```typescript
+     * // Java-style hierarchical naming (recommended)
+     * const log = FlinkLogFactory.createLogger("flink.ai.openai");
+     * const dbLog = FlinkLogFactory.createLogger("flink.database.mongodb");
+     *
+     * // Case insensitive - these create the same logger
+     * const log1 = FlinkLogFactory.createLogger("flink.ai.openai");
+     * const log2 = FlinkLogFactory.createLogger("Flink.AI.OpenAI");  // Same instance
+     * ```
+     */
+    FlinkLogFactory.createLogger = function (componentName) {
+        // Initialize from environment and config file if not already done
+        if (!FlinkLogFactory.initialized) {
+            var loadFlinkConfig = require("./utils/loadFlinkConfig").loadFlinkConfig;
+            var flinkConfig = loadFlinkConfig();
+            FlinkLogFactory.configure(flinkConfig === null || flinkConfig === void 0 ? void 0 : flinkConfig.logging);
+        }
+        // Normalize to lowercase for consistent lookup
+        var normalized = FlinkLogFactory.normalize(componentName);
+        if (!FlinkLogFactory.loggers.has(normalized)) {
+            var logger = new ComponentLogger(normalized);
+            FlinkLogFactory.loggers.set(normalized, logger);
+            // Resolve level through hierarchical matching
+            var resolvedLevel = FlinkLogFactory.resolveComponentLevel(normalized);
+            if (resolvedLevel) {
+                logger.setLevel(resolvedLevel);
+            }
+        }
+        return FlinkLogFactory.loggers.get(normalized);
+    };
+    FlinkLogFactory.globalLevel = "info";
+    FlinkLogFactory.loggers = new Map();
+    FlinkLogFactory.initialized = false;
+    FlinkLogFactory.showTimestamps = true;
+    /**
+     * Store component configurations from environment/config for lazy application
+     */
+    FlinkLogFactory.componentConfigs = {};
+    /**
+     * Hierarchical prefix configurations (Java-style)
+     * Sorted by specificity (most specific first) for efficient matching
+     */
+    FlinkLogFactory.hierarchicalConfigs = [];
+    /**
+     * Wildcard pattern configurations (optional, advanced)
+     * Sorted by specificity (most specific first) for efficient matching
+     */
+    FlinkLogFactory.wildcardConfigs = [];
+    return FlinkLogFactory;
+}());
+exports.FlinkLogFactory = FlinkLogFactory;

package/dist/src/FlinkRepo.d.ts

@@ -14,7 +14,7 @@ export declare abstract class FlinkRepo<C extends FlinkContext, Model extends Do
     collection: Collection;
     private _ctx?;
     set ctx(ctx: FlinkContext);
-    get ctx(): FlinkContext;
+    get ctx(): C;
     constructor(collectionName: string, db: Db, client?: MongoClient | undefined);
     findAll(query?: {}): Promise<Model[]>;
     getById(id: string | ObjectId): Promise<Model | null>;
@@ -22,6 +22,10 @@ export declare abstract class FlinkRepo<C extends FlinkContext, Model extends Do
     create<C = Omit<Model, "_id">>(model: C): Promise<C & {
         _id: string;
     }>;
+    updateById(id: string | ObjectId, model: PartialModel<Model>): Promise<Model | null>;
+    /**
+     * @deprecated Use `updateById` instead. This will be removed in a future major version.
+     */
     updateOne(id: string | ObjectId, model: PartialModel<Model>): Promise<Model | null>;
     updateMany<U = PartialModel<Model>>(query: any, model: U): Promise<number>;
     deleteById(id: string | ObjectId): Promise<number>;
@@ -33,6 +37,10 @@ export declare abstract class FlinkRepo<C extends FlinkContext, Model extends Do
      * @returns
      */
     buildId(id: string | ObjectId): ObjectId;
-    private objectIdToString;
+    protected objectIdToString<T>(doc: T & {
+        _id?: any;
+    }): T & {
+        _id?: any;
+    };
 }
 export {};

package/dist/src/FlinkRepo.js

@@ -139,7 +139,7 @@ var FlinkRepo = /** @class */ (function () {
             });
         });
     };
-    FlinkRepo.prototype.updateOne = function (id, model) {
+    FlinkRepo.prototype.updateById = function (id, model) {
         return __awaiter(this, void 0, void 0, function () {
             var oid, _id, modelWithoutId, res;
             return __generator(this, function (_a) {
@@ -161,6 +161,16 @@ var FlinkRepo = /** @class */ (function () {
             });
         });
     };
+    /**
+     * @deprecated Use `updateById` instead. This will be removed in a future major version.
+     */
+    FlinkRepo.prototype.updateOne = function (id, model) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.updateById(id, model)];
+            });
+        });
+    };
     FlinkRepo.prototype.updateMany = function (query, model) {
         return __awaiter(this, void 0, void 0, function () {
             var _a, _id, modelWithoutId, modifiedCount;