@zintrust/core 0.1.0 → 0.1.2

package/src/config/index.d.ts

@@ -6,6 +6,7 @@ export { appConfig, type AppConfig } from './app';
 export { cacheConfig, type CacheConfig } from './cache';
 export { databaseConfig, type DatabaseConfig } from './database';
 export { microservicesConfig, type MicroservicesConfig } from './microservices';
+export { middlewareConfig, type MiddlewareConfig } from './middleware';
 export { queueConfig, type QueueConfig } from './queue';
 export { securityConfig } from './security';
 export { storageConfig, type StorageConfig } from './storage';
@@ -219,8 +220,8 @@ export declare const config: Readonly<{
         };
     }>;
     readonly storage: Readonly<{
-        default: string;
-        drivers: {
+        readonly default: string;
+        readonly drivers: {
             local: {
                 driver: "local";
                 root: string;
@@ -229,14 +230,23 @@ export declare const config: Readonly<{
             };
             s3: {
                 driver: "s3";
-                key: string;
-                secret: string;
+                accessKeyId: string;
+                secretAccessKey: string;
                 region: string;
                 bucket: string;
                 url: string;
                 endpoint: string;
                 usePathStyleUrl: boolean;
             };
+            r2: {
+                driver: "r2";
+                accessKeyId: string;
+                secretAccessKey: string;
+                region: string;
+                bucket: string;
+                endpoint: string;
+                url: string;
+            };
             gcs: {
                 driver: "gcs";
                 projectId: string;
@@ -246,8 +256,8 @@ export declare const config: Readonly<{
             };
         };
         getDriver(this: {
-            default: string;
-            drivers: {
+            readonly default: string;
+            readonly drivers: {
                 local: {
                     driver: "local";
                     root: string;
@@ -256,14 +266,23 @@ export declare const config: Readonly<{
                 };
                 s3: {
                     driver: "s3";
-                    key: string;
-                    secret: string;
+                    accessKeyId: string;
+                    secretAccessKey: string;
                     region: string;
                     bucket: string;
                     url: string;
                     endpoint: string;
                     usePathStyleUrl: boolean;
                 };
+                r2: {
+                    driver: "r2";
+                    accessKeyId: string;
+                    secretAccessKey: string;
+                    region: string;
+                    bucket: string;
+                    endpoint: string;
+                    url: string;
+                };
                 gcs: {
                     driver: "gcs";
                     projectId: string;
@@ -279,13 +298,21 @@ export declare const config: Readonly<{
             visibility: string;
         } | {
             driver: "s3";
-            key: string;
-            secret: string;
+            accessKeyId: string;
+            secretAccessKey: string;
             region: string;
             bucket: string;
             url: string;
             endpoint: string;
             usePathStyleUrl: boolean;
+        } | {
+            driver: "r2";
+            accessKeyId: string;
+            secretAccessKey: string;
+            region: string;
+            bucket: string;
+            endpoint: string;
+            url: string;
         } | {
             driver: "gcs";
             projectId: string;
@@ -293,16 +320,16 @@ export declare const config: Readonly<{
             bucket: string;
             url: string;
         };
-        temp: {
+        readonly temp: {
             path: string;
             maxAge: number;
         };
-        uploads: {
+        readonly uploads: {
             maxSize: string;
             allowedMimes: string;
             path: string;
         };
-        backups: {
+        readonly backups: {
             path: string;
             driver: string;
         };
@@ -379,6 +406,7 @@ export declare const config: Readonly<{
             readonly bcryptRounds: number;
         };
     }>;
+    readonly middleware: Readonly<import("./middleware").MiddlewareConfig>;
     readonly microservices: Readonly<{
         readonly enabled: boolean;
         readonly services: string[];
@@ -441,18 +469,16 @@ export declare const config: Readonly<{
                 driver: "redis";
                 host: string;
                 port: number;
-                password: string;
-                database: number;
                 ttl: number;
             };
-            memcached: {
-                driver: "memcached";
-                servers: string[];
+            mongodb: {
+                driver: "mongodb";
+                uri: string;
+                db: string;
                 ttl: number;
             };
-            file: {
-                driver: "file";
-                path: string;
+            kv: {
+                driver: "kv";
                 ttl: number;
             };
         };
@@ -463,23 +489,21 @@ export declare const config: Readonly<{
             driver: "redis";
             host: string;
             port: number;
-            password: string | undefined;
-            database: number;
             ttl: number;
         } | {
-            driver: "memcached";
-            servers: string[];
+            driver: "mongodb";
+            uri: string;
+            db: string;
             ttl: number;
         } | {
-            driver: "file";
-            path: string;
+            driver: "kv";
             ttl: number;
         };
         keyPrefix: string;
         ttl: number;
     }>;
     readonly queue: Readonly<{
-        default: "database" | "redis" | "sync" | "rabbitmq" | "sqs";
+        default: "redis" | "database" | "sync" | "rabbitmq" | "sqs";
         drivers: {
             sync: {
                 driver: "sync";

package/src/config/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH,OAAO,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,KAAK,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACtF,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQR,CAAC;AAEZ,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAWH,OAAO,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,KAAK,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AACtF,OAAO,EAAE,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASR,CAAC;AAEZ,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC"}

package/src/config/index.js

@@ -6,6 +6,7 @@ import { appConfig } from './app';
 import { cacheConfig } from './cache';
 import { databaseConfig } from './database';
 import { microservicesConfig } from './microservices';
+import { middlewareConfig } from './middleware';
 import { queueConfig } from './queue';
 import { securityConfig } from './security';
 import { storageConfig } from './storage';
@@ -13,6 +14,7 @@ export { appConfig } from './app';
 export { cacheConfig } from './cache';
 export { databaseConfig } from './database';
 export { microservicesConfig } from './microservices';
+export { middlewareConfig } from './middleware';
 export { queueConfig } from './queue';
 export { securityConfig } from './security';
 export { storageConfig } from './storage';
@@ -25,6 +27,7 @@ export const config = Object.freeze({
     database: databaseConfig,
     storage: storageConfig,
     security: securityConfig,
+    middleware: middlewareConfig,
     microservices: microservicesConfig,
     cache: cacheConfig,
     queue: queueConfig,

package/src/config/logger.d.ts

@@ -5,12 +5,14 @@ interface ILogger {
     error(message: string, error?: unknown, category?: string): void;
     fatal(message: string, error?: unknown, category?: string): void;
 }
+export declare const cleanLogsOnce: () => Promise<string[]>;
 export declare const Logger: Readonly<{
     debug: (message: string, data?: unknown, category?: string) => void;
     info: (message: string, data?: unknown, category?: string) => void;
     warn: (message: string, data?: unknown, category?: string) => void;
     error: (message: string, error?: unknown, category?: string) => void;
     fatal: (message: string, error?: unknown, category?: string) => void;
+    cleanLogsOnce: () => Promise<string[]>;
     scope: (scope: string) => ILogger;
 }>;
 export default Logger;

package/src/config/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/config/logger.ts"],"names":[],"mappings":"AAOA,UAAU,OAAO;IACf,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChE,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjE,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClE;AAwED,eAAO,MAAM,MAAM;qBArDQ,MAAM,SAAS,OAAO,aAAa,MAAM,KAAG,IAAI;oBAOjD,MAAM,SAAS,OAAO,aAAa,MAAM,KAAG,IAAI;oBAKhD,MAAM,SAAS,OAAO,aAAa,MAAM,KAAG,IAAI;qBAK/C,MAAM,UAAU,OAAO,aAAa,MAAM,KAAG,IAAI;qBAMjD,MAAM,UAAU,OAAO,aAAa,MAAM,KAAG,IAAI;mBAS1C,MAAM,KAAG,OAAO;EA4BhD,CAAC;AAEH,eAAe,MAAM,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/config/logger.ts"],"names":[],"mappings":"AAQA,UAAU,OAAO;IACf,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChE,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjE,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClE;AA0VD,eAAO,MAAM,aAAa,QAAa,OAAO,CAAC,MAAM,EAAE,CAYtD,CAAC;AAEF,eAAO,MAAM,MAAM;qBAzJQ,MAAM,SAAS,OAAO,aAAa,MAAM,KAAG,IAAI;oBAsBjD,MAAM,SAAS,OAAO,aAAa,MAAM,KAAG,IAAI;oBAoBhD,MAAM,SAAS,OAAO,aAAa,MAAM,KAAG,IAAI;qBAoB/C,MAAM,UAAU,OAAO,aAAa,MAAM,KAAG,IAAI;qBA0BjD,MAAM,UAAU,OAAO,aAAa,MAAM,KAAG,IAAI;yBAmDrC,OAAO,CAAC,MAAM,EAAE,CAAC;mBArBtB,MAAM,KAAG,OAAO;EA2ChD,CAAC;AAEH,eAAe,MAAM,CAAC"}

package/src/config/logger.js

@@ -3,9 +3,124 @@
  * Sealed namespace pattern - all exports through Logger namespace
  * Replaces console.* calls throughout the codebase
  */
+import { appConfig } from './app';
 import { Env } from './env';
-const isDevelopment = Env.NODE_ENV === 'development' || Env.NODE_ENV === undefined;
-const isProduction = Env.NODE_ENV === 'production';
+const isDevelopment = () => appConfig.isDevelopment();
+const isProduction = () => appConfig.isProduction();
+const getLogFormat = () => Env.get('LOG_FORMAT', 'text');
+const isJsonFormat = (value) => value === 'json';
+const SENSITIVE_FIELDS = new Set([
+    'password',
+    'token',
+    'authorization',
+    'secret',
+    'apikey',
+    'api_key',
+    'jwt',
+    'bearer',
+]);
+const redactSensitiveData = (data) => {
+    const seen = new WeakSet();
+    const walk = (value) => {
+        if (Array.isArray(value)) {
+            if (seen.has(value))
+                return '[Circular]';
+            seen.add(value);
+            return value.map((v) => walk(v));
+        }
+        if (typeof value === 'object' && value !== null) {
+            const asObj = value;
+            if (seen.has(asObj))
+                return '[Circular]';
+            seen.add(asObj);
+            const out = {};
+            for (const [key, inner] of Object.entries(asObj)) {
+                if (SENSITIVE_FIELDS.has(key.toLowerCase())) {
+                    out[key] = '[REDACTED]';
+                }
+                else {
+                    out[key] = walk(inner);
+                }
+            }
+            return out;
+        }
+        return value;
+    };
+    return walk(data);
+};
+const safeStringify = (obj, indent = false) => {
+    const seen = new WeakSet();
+    return JSON.stringify(obj, (_key, value) => {
+        if (typeof value === 'object' && value !== null) {
+            const asObj = value;
+            if (seen.has(asObj))
+                return '[Circular]';
+            seen.add(asObj);
+        }
+        return value;
+    }, indent ? 2 : 0);
+};
+let fileWriterPromise;
+let fileWriter;
+const getFileWriter = () => {
+    if (fileWriter !== undefined)
+        return;
+    if (fileWriterPromise !== undefined)
+        return;
+    fileWriterPromise = import('./FileLogWriter')
+        .then((mod) => {
+        fileWriter = mod.FileLogWriter;
+        return mod;
+    })
+        .catch(() => {
+        fileWriterPromise = undefined;
+        return { FileLogWriter: { write: (_line) => undefined } };
+    });
+};
+const shouldLogToFile = () => {
+    // Prefer dynamic lookup so late-bound env (tests, some runtimes) is respected.
+    if (!Env.getBool('LOG_TO_FILE', false))
+        return false;
+    if (typeof process === 'undefined')
+        return false;
+    return true;
+};
+const buildFileLine = (params) => {
+    if (isJsonFormat(getLogFormat()))
+        return params.formatted;
+    let line = params.formatted;
+    if (typeof params.errorMessage === 'string' && params.errorMessage.length > 0) {
+        line = `${line} ${params.errorMessage}`;
+    }
+    else if (params.data !== undefined && params.data !== '') {
+        line = `${line} ${safeStringify(redactSensitiveData(params.data))}`;
+    }
+    return line;
+};
+const writeToFile = (line) => {
+    if (!shouldLogToFile())
+        return;
+    if (fileWriter !== undefined) {
+        fileWriter.write(line);
+        return;
+    }
+    getFileWriter();
+    fileWriterPromise?.then((mod) => mod.FileLogWriter.write(line));
+};
+const formatLogMessage = (params) => {
+    if (isJsonFormat(getLogFormat())) {
+        return safeStringify({
+            timestamp: new Date().toISOString(),
+            level: params.level,
+            message: params.message,
+            category: params.category,
+            data: redactSensitiveData(params.data),
+            error: params.errorMessage,
+        });
+    }
+    // text format
+    return `[${params.level.toUpperCase()}] ${params.message}`;
+};
 /**
  * Helper to extract error message from unknown error type
  */
@@ -16,33 +131,162 @@ const getErrorMessage = (error) => {
     if (error instanceof Error) {
         return error.message;
     }
-    return String(error);
+    if (typeof error === 'string')
+        return error;
+    if (typeof error === 'number' || typeof error === 'bigint')
+        return error.toString();
+    if (typeof error === 'boolean')
+        return error ? 'true' : 'false';
+    if (typeof error === 'symbol')
+        return error.toString();
+    if (typeof error === 'function')
+        return '[Function]';
+    try {
+        return safeStringify(error);
+    }
+    catch {
+        return '[Unserializable error]';
+    }
+};
+const emitCloudLogs = (event) => {
+    // Lazy-load to avoid cycles and avoid cost when disabled.
+    void (async () => {
+        try {
+            if (event.level === 'error' || event.level === 'fatal') {
+                const mod = await import('./logging/KvLogger');
+                void mod.KvLogger.enqueue(event);
+            }
+        }
+        catch {
+            // best-effort
+        }
+        try {
+            if (event.level === 'warn' || event.level === 'error' || event.level === 'fatal') {
+                const mod = await import('./logging/SlackLogger');
+                void mod.SlackLogger.enqueue(event);
+            }
+        }
+        catch {
+            // best-effort
+        }
+        try {
+            const mod = await import('./logging/HttpLogger');
+            void mod.HttpLogger.enqueue(event);
+        }
+        catch {
+            // best-effort
+        }
+    })();
 };
 // Private helper functions
 const logDebug = (message, data, category) => {
     String(category);
-    if (isDevelopment) {
-        console.debug(`[DEBUG] ${message}`, data ?? ''); // eslint-disable-line no-console
+    if (isDevelopment()) {
+        const timestamp = new Date().toISOString();
+        const out = formatLogMessage({ level: 'debug', message, data, category });
+        writeToFile(buildFileLine({ formatted: out, data }));
+        if (isJsonFormat(getLogFormat())) {
+            console.debug(out); // eslint-disable-line no-console
+            return;
+        }
+        console.debug(out, data ?? ''); // eslint-disable-line no-console
+        emitCloudLogs({
+            timestamp,
+            level: 'debug',
+            message,
+            category,
+            data: redactSensitiveData(data),
+        });
     }
 };
 const logInfo = (message, data, category) => {
     String(category);
-    console.log(`[INFO] ${message}`, data ?? ''); // eslint-disable-line no-console
+    const timestamp = new Date().toISOString();
+    const out = formatLogMessage({ level: 'info', message, data, category });
+    writeToFile(buildFileLine({ formatted: out, data }));
+    if (isJsonFormat(getLogFormat())) {
+        console.log(out); // eslint-disable-line no-console
+    }
+    else {
+        console.log(out, data ?? ''); // eslint-disable-line no-console
+    }
+    emitCloudLogs({
+        timestamp,
+        level: 'info',
+        message,
+        category,
+        data: redactSensitiveData(data),
+    });
 };
 const logWarn = (message, data, category) => {
     String(category);
-    console.warn(`[WARN] ${message}`, data ?? ''); // eslint-disable-line no-console
+    const timestamp = new Date().toISOString();
+    const out = formatLogMessage({ level: 'warn', message, data, category });
+    writeToFile(buildFileLine({ formatted: out, data }));
+    if (isJsonFormat(getLogFormat())) {
+        console.warn(out); // eslint-disable-line no-console
+    }
+    else {
+        console.warn(out, data ?? ''); // eslint-disable-line no-console
+    }
+    emitCloudLogs({
+        timestamp,
+        level: 'warn',
+        message,
+        category,
+        data: redactSensitiveData(data),
+    });
 };
 const logError = (message, error, category) => {
     const errorMessage = getErrorMessage(error);
     String(category);
-    console.error(`[ERROR] ${message}`, errorMessage); // eslint-disable-line no-console
+    const timestamp = new Date().toISOString();
+    const out = formatLogMessage({
+        level: 'error',
+        message,
+        category,
+        errorMessage,
+    });
+    writeToFile(buildFileLine({ formatted: out, errorMessage }));
+    if (isJsonFormat(getLogFormat())) {
+        console.error(out); // eslint-disable-line no-console
+    }
+    else {
+        console.error(out, errorMessage); // eslint-disable-line no-console
+    }
+    emitCloudLogs({
+        timestamp,
+        level: 'error',
+        message,
+        category,
+        error: errorMessage,
+    });
 };
 const logFatal = (message, error, category) => {
     const errorMessage = getErrorMessage(error);
     String(category);
-    console.error(`[FATAL] ${message}`, errorMessage); // eslint-disable-line no-console
-    if (isProduction && typeof process !== 'undefined') {
+    const timestamp = new Date().toISOString();
+    const out = formatLogMessage({
+        level: 'fatal',
+        message,
+        category,
+        errorMessage,
+    });
+    writeToFile(buildFileLine({ formatted: out, errorMessage }));
+    if (isJsonFormat(getLogFormat())) {
+        console.error(out); // eslint-disable-line no-console
+    }
+    else {
+        console.error(out, errorMessage); // eslint-disable-line no-console
+    }
+    emitCloudLogs({
+        timestamp,
+        level: 'fatal',
+        message,
+        category,
+        error: errorMessage,
+    });
+    if (isProduction() && typeof process !== 'undefined') {
         process.exit(1);
     }
 };
@@ -65,13 +309,28 @@ const createLoggerScope = (scope) => {
         },
     };
 };
-// Sealed namespace with all logger functionality
+// Expose log cleanup API and sealed namespace with all logger functionality
+export const cleanLogsOnce = async () => {
+    if (!shouldLogToFile())
+        return [];
+    try {
+        const mod = await import('./FileLogWriter');
+        const deleted = mod.cleanOnce();
+        logInfo('Log cleanup executed', { deletedCount: deleted.length });
+        return deleted;
+    }
+    catch (err) {
+        logError('Log cleanup failed', err);
+        return [];
+    }
+};
 export const Logger = Object.freeze({
     debug: logDebug,
     info: logInfo,
     warn: logWarn,
     error: logError,
     fatal: logFatal,
+    cleanLogsOnce,
     scope: createLoggerScope,
 });
 export default Logger;

package/src/config/logging/HttpLogger.d.ts

@@ -0,0 +1,23 @@
+/**
+ * HTTP Endpoint Logger
+ * Sends logs to an external HTTP logging service.
+ *
+ * Enabled via env:
+ *  - HTTP_LOG_ENABLED (default: false)
+ *  - HTTP_LOG_ENDPOINT_URL
+ *  - HTTP_LOG_BATCH_SIZE (default: 50)
+ *  - HTTP_LOG_AUTH_TOKEN (optional)
+ */
+export type HttpLogEvent = {
+    timestamp: string;
+    level: 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+    message: string;
+    category?: string;
+    data?: unknown;
+    error?: string;
+};
+export declare const HttpLogger: Readonly<{
+    enqueue(event: HttpLogEvent): Promise<void>;
+}>;
+export default HttpLogger;
+//# sourceMappingURL=HttpLogger.d.ts.map

package/src/config/logging/HttpLogger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpLogger.d.ts","sourceRoot":"","sources":["../../../../src/config/logging/HttpLogger.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH,MAAM,MAAM,YAAY,GAAG;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAkFF,eAAO,MAAM,UAAU;mBACA,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;EAYjD,CAAC;AAEH,eAAe,UAAU,CAAC"}

package/src/config/logging/HttpLogger.js

@@ -0,0 +1,93 @@
+/**
+ * HTTP Endpoint Logger
+ * Sends logs to an external HTTP logging service.
+ *
+ * Enabled via env:
+ *  - HTTP_LOG_ENABLED (default: false)
+ *  - HTTP_LOG_ENDPOINT_URL
+ *  - HTTP_LOG_BATCH_SIZE (default: 50)
+ *  - HTTP_LOG_AUTH_TOKEN (optional)
+ */
+import { delay } from '../../common/index';
+import { Env } from '../env';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+import { HttpClient } from '../../tools/http/Http';
+const isEnabled = () => Env.getBool('HTTP_LOG_ENABLED', false);
+let buffer = [];
+let flushPromise;
+const postBatch = async (events) => {
+    const endpoint = Env.get('HTTP_LOG_ENDPOINT_URL').trim();
+    if (endpoint.length === 0) {
+        throw ErrorFactory.createConfigError('HTTP_LOG_ENDPOINT_URL is required when HTTP logging is enabled');
+    }
+    const token = Env.get('HTTP_LOG_AUTH_TOKEN').trim();
+    const builder = HttpClient.post(endpoint, {
+        sentAt: new Date().toISOString(),
+        count: events.length,
+        events,
+    });
+    if (token.length > 0) {
+        builder.withAuth(token, 'Bearer');
+    }
+    await builder.send();
+};
+const flushNow = async () => {
+    const toSend = buffer;
+    buffer = [];
+    if (!isEnabled())
+        return;
+    if (toSend.length === 0)
+        return;
+    const maxRetries = 3;
+    const attemptPost = async (attempt) => {
+        try {
+            await postBatch(toSend);
+        }
+        catch {
+            if (attempt >= maxRetries)
+                return;
+            const backoffMs = 100 * 2 ** attempt;
+            await delay(backoffMs);
+            await attemptPost(attempt + 1);
+        }
+    };
+    await attemptPost(0);
+};
+const scheduleFlush = async () => {
+    if (flushPromise !== undefined)
+        return flushPromise;
+    const promise = new Promise((resolve) => {
+        const run = async () => {
+            try {
+                await flushNow();
+            }
+            finally {
+                resolve(undefined);
+            }
+        };
+        if (typeof globalThis.setTimeout !== 'function') {
+            void run();
+            return;
+        }
+        globalThis.setTimeout(() => {
+            void run();
+        }, 0);
+    });
+    flushPromise = promise.finally(() => {
+        flushPromise = undefined;
+    });
+    return flushPromise;
+};
+export const HttpLogger = Object.freeze({
+    async enqueue(event) {
+        if (!isEnabled())
+            return Promise.resolve(); // NOSONAR
+        buffer.push(event);
+        const batchSize = Math.max(1, Env.getInt('HTTP_LOG_BATCH_SIZE', 50));
+        if (buffer.length >= batchSize) {
+            return scheduleFlush();
+        }
+        return scheduleFlush();
+    },
+});
+export default HttpLogger;