@mrxsys/mrx-core 2.11.0-2-and-276-20251029 → 2.11.0-2-and-277-20251030

package/dist/modules/logger/index.js

@@ -0,0 +1,282 @@
+// @bun
+import {
+  LOGGER_ERROR_KEYS
+} from "../../chunk-rz5p4j3p.js";
+import {
+  TypedEventEmitter
+} from "../../chunk-mvrxngm7.js";
+import {
+  BaseError
+} from "../../chunk-9cgzhc50.js";
+
+// source/modules/logger/worker-logger.ts
+var workerFunction = () => {
+  const sinks = {};
+  const self = globalThis;
+  const processLogEntry = async (log) => {
+    await Promise.all(log.sinkNames.map(async (sinkName) => {
+      const sink = sinks[sinkName];
+      if (!sink)
+        return;
+      try {
+        await sink.log(log.level, log.timestamp, log.object);
+      } catch (error) {
+        self.postMessage({
+          type: "SINK_LOG_ERROR",
+          sinkName,
+          error,
+          object: log.object
+        });
+      }
+    }));
+  };
+  self.addEventListener("message", async (event) => {
+    switch (event.data.type) {
+      case "REGISTER_SINK": {
+        const {
+          sinkName,
+          sinkClassName,
+          sinkClassString,
+          sinkArgs
+        } = event.data;
+        try {
+          const factory = new Function("sinkArgs", `
+						${sinkClassString}
+						return new ${sinkClassName}(...sinkArgs);
+					`);
+          sinks[sinkName] = factory(sinkArgs);
+        } catch (error) {
+          self.postMessage({
+            type: "REGISTER_SINK_ERROR",
+            sinkName,
+            error
+          });
+        }
+        break;
+      }
+      case "LOG_BATCH": {
+        const { logs } = event.data;
+        try {
+          for (const log of logs)
+            await processLogEntry(log);
+        } finally {
+          self.postMessage({ type: "BATCH_COMPLETE" });
+        }
+        break;
+      }
+      case "CLOSE": {
+        await Promise.all(Object.entries(sinks).map(async ([name, sink]) => {
+          try {
+            await sink.close?.();
+          } catch (error) {
+            self.postMessage({
+              type: "SINK_CLOSE_ERROR",
+              sinkName: name,
+              error
+            });
+          }
+        }));
+        self.postMessage({ type: "CLOSE_COMPLETE" });
+        break;
+      }
+    }
+  });
+};
+
+// source/modules/logger/logger.ts
+class Logger extends TypedEventEmitter {
+  _sinks;
+  _sinkKeys = [];
+  _worker;
+  _maxPendingLogs;
+  _maxMessagesInFlight;
+  _batchSize;
+  _batchTimeout;
+  _autoEnd;
+  _flushOnBeforeExit;
+  _pendingLogs = [];
+  _messagesInFlight = 0;
+  _batchTimer = null;
+  _isWriting = false;
+  _flushResolvers = [];
+  _closeResolver = null;
+  _backpressureResolver = null;
+  _handleExit = () => {
+    this._worker.terminate();
+  };
+  _handleWorkerClose = () => {
+    process.off("beforeExit", this._handleBeforeExit);
+    process.off("exit", this._handleExit);
+  };
+  constructor(options) {
+    super();
+    const {
+      autoEnd = true,
+      batchSize = 50,
+      batchTimeout = 0.1,
+      flushOnBeforeExit = true,
+      maxMessagesInFlight = 100,
+      maxPendingLogs = 1e4
+    } = options ?? {};
+    this._sinks = {};
+    this._maxPendingLogs = maxPendingLogs;
+    this._maxMessagesInFlight = maxMessagesInFlight;
+    this._batchSize = batchSize;
+    this._batchTimeout = batchTimeout;
+    this._autoEnd = autoEnd;
+    this._flushOnBeforeExit = flushOnBeforeExit;
+    this._worker = new Worker(URL.createObjectURL(new Blob([`(${workerFunction.toString()})()`], { type: "application/javascript" })), { type: "module" });
+    this._setupWorkerMessages();
+    if (this._autoEnd)
+      this._setupAutoEnd();
+  }
+  registerSink(sinkName, sinkConstructor, ...sinkArgs) {
+    if (this._sinks[sinkName])
+      throw new BaseError(LOGGER_ERROR_KEYS.SINK_ALREADY_ADDED);
+    this._worker.postMessage({
+      type: "REGISTER_SINK",
+      sinkName,
+      sinkClassName: sinkConstructor.name,
+      sinkClassString: sinkConstructor.toString(),
+      sinkArgs
+    });
+    this._sinks[sinkName] = sinkConstructor;
+    this._sinkKeys.push(sinkName);
+    return this;
+  }
+  error(object, sinkNames = this._sinkKeys) {
+    this._enqueue("ERROR", object, sinkNames);
+  }
+  warn(object, sinkNames = this._sinkKeys) {
+    this._enqueue("WARN", object, sinkNames);
+  }
+  info(object, sinkNames = this._sinkKeys) {
+    this._enqueue("INFO", object, sinkNames);
+  }
+  debug(object, sinkNames = this._sinkKeys) {
+    this._enqueue("DEBUG", object, sinkNames);
+  }
+  log(object, sinkNames = this._sinkKeys) {
+    this._enqueue("LOG", object, sinkNames);
+  }
+  async flush() {
+    if (this._pendingLogs.length === 0 && this._messagesInFlight === 0)
+      return;
+    return new Promise((resolve) => {
+      this._flushResolvers.push(resolve);
+      if (!this._isWriting && this._pendingLogs.length > 0) {
+        this._isWriting = true;
+        this._processPendingLogs();
+      }
+    });
+  }
+  async close() {
+    await this.flush();
+    return new Promise((resolve) => {
+      this._closeResolver = resolve;
+      this._worker.postMessage({ type: "CLOSE" });
+    });
+  }
+  _enqueue(level, object, sinkNames) {
+    if (this._sinkKeys.length === 0)
+      throw new BaseError(LOGGER_ERROR_KEYS.NO_SINKS_PROVIDED, { level, object });
+    if (this._pendingLogs.length >= this._maxPendingLogs)
+      return;
+    this._pendingLogs.push({
+      sinkNames: sinkNames ?? this._sinkKeys,
+      level,
+      timestamp: Date.now(),
+      object
+    });
+    if (this._pendingLogs.length >= this._batchSize) {
+      if (this._batchTimer !== null) {
+        clearTimeout(this._batchTimer);
+        this._batchTimer = null;
+      }
+      this._triggerProcessing();
+    } else if (this._batchTimeout > 0 && this._batchTimer === null) {
+      this._batchTimer = setTimeout(() => {
+        this._batchTimer = null;
+        this._triggerProcessing();
+      }, this._batchTimeout);
+    }
+  }
+  _triggerProcessing() {
+    if (this._isWriting)
+      return;
+    this._isWriting = true;
+    this._processPendingLogs();
+  }
+  async _processPendingLogs() {
+    while (this._pendingLogs.length > 0) {
+      if (this._messagesInFlight >= this._maxMessagesInFlight)
+        await new Promise((resolve) => {
+          this._backpressureResolver = resolve;
+        });
+      const batch = this._pendingLogs.splice(0, this._batchSize);
+      this._messagesInFlight++;
+      this._worker.postMessage({
+        type: "LOG_BATCH",
+        logs: batch
+      });
+    }
+    this._isWriting = false;
+    this.emit("drained");
+  }
+  _releaseBatch() {
+    this._messagesInFlight--;
+    if (this._backpressureResolver !== null) {
+      this._backpressureResolver();
+      this._backpressureResolver = null;
+    }
+  }
+  _setupWorkerMessages() {
+    this._worker.addEventListener("message", (event) => {
+      switch (event.data.type) {
+        case "BATCH_COMPLETE":
+          this._releaseBatch();
+          if (this._messagesInFlight === 0 && this._pendingLogs.length === 0 && this._flushResolvers.length > 0) {
+            for (const resolve of this._flushResolvers)
+              resolve();
+            this._flushResolvers.length = 0;
+          }
+          break;
+        case "SINK_LOG_ERROR":
+          this.emit("sinkError", new BaseError(LOGGER_ERROR_KEYS.SINK_LOG_ERROR, event.data));
+          this._releaseBatch();
+          break;
+        case "SINK_CLOSE_ERROR":
+          this.emit("sinkError", new BaseError(LOGGER_ERROR_KEYS.SINK_CLOSE_ERROR, event.data));
+          break;
+        case "REGISTER_SINK_ERROR":
+          this.emit("registerSinkError", new BaseError(LOGGER_ERROR_KEYS.REGISTER_SINK_ERROR, event.data));
+          break;
+        case "CLOSE_COMPLETE":
+          this._worker.terminate();
+          if (this._closeResolver) {
+            this._closeResolver();
+            this._closeResolver = null;
+          }
+          break;
+      }
+    });
+  }
+  _setupAutoEnd() {
+    process.on("beforeExit", this._handleBeforeExit);
+    process.on("exit", this._handleExit);
+    this._worker.addEventListener("close", this._handleWorkerClose);
+  }
+  _handleBeforeExit = () => {
+    if (this._flushOnBeforeExit)
+      this.flush().then(() => this.close()).catch((error) => {
+        this.emit("onBeforeExitError", new BaseError(LOGGER_ERROR_KEYS.BEFORE_EXIT_FLUSH_ERROR, { error }));
+      });
+    else
+      this.close().catch((error) => {
+        this.emit("onBeforeExitError", new BaseError(LOGGER_ERROR_KEYS.BEFORE_EXIT_CLOSE_ERROR, { error }));
+      });
+  };
+}
+export {
+  Logger
+};

package/dist/modules/logger/logger.d.ts

@@ -1,4 +1,4 @@
-import { TypedEventEmitter } from '#/modules/typed-event-emitter/typed-event-emitter';
+import { TypedEventEmitter } from '../../modules/typed-event-emitter/typed-event-emitter';
 import type { LoggerEvent } from './events/logger-events';
 import type { LoggerOptions } from './types/logger-options';
 import type { LoggerSink } from './types/logger-sink';

package/dist/modules/logger/sinks/console-logger.d.ts

@@ -1,5 +1,5 @@
-import type { LogLevels } from '#/modules/logger/types/log-levels';
-import type { LoggerSink } from '#/modules/logger/types/logger-sink';
+import type { LogLevels } from '../../../modules/logger/types/log-levels';
+import type { LoggerSink } from '../../../modules/logger/types/logger-sink';
 /**
 * ConsoleLoggerSink implements LoggerSink to provide logging functionality to the console.
 */

package/dist/modules/logger/sinks/devnull-logger.d.ts

@@ -1,4 +1,4 @@
-import type { LoggerSink } from '#/modules/logger/types/logger-sink';
+import type { LoggerSink } from '../../../modules/logger/types/logger-sink';
 /**
  * DevNullLoggerSink implements LoggerSink to discard all logs (like /dev/null).
  * Useful for benchmarking the logger overhead without I/O.

package/dist/modules/logger/sinks/file-logger/file-logger.d.ts

@@ -1,5 +1,5 @@
-import type { LogLevels } from '#/modules/logger/types/log-levels';
-import type { LoggerSink } from '#/modules/logger/types/logger-sink';
+import type { LogLevels } from '../../../../modules/logger/types/log-levels';
+import type { LoggerSink } from '../../../../modules/logger/types/logger-sink';
 export interface FileLoggerConfig {
     /**
      * Path to the file to log to.

package/dist/modules/logger/sinks/index.js

@@ -0,0 +1,66 @@
+// @bun
+import {
+  BaseError
+} from "../../../chunk-9cgzhc50.js";
+
+// source/modules/logger/sinks/console-logger.ts
+class ConsoleLoggerSink {
+  async log(level, timestamp, object) {
+    const logEntry = { timestamp, level, content: object };
+    await Bun.write(Bun.stdout, JSON.stringify(logEntry) + `
+`);
+  }
+}
+// source/modules/logger/sinks/devnull-logger.ts
+class DevNullLoggerSink {
+  log() {}
+}
+// source/modules/logger/sinks/file-logger/enums/file-logger-error-keys.ts
+var FILE_LOGGER_ERROR_KEYS = {
+  FAILED_TO_CLOSE_STREAM: "mrx-core.file_logger.error.failed_to_close_stream"
+};
+// source/modules/logger/sinks/file-logger/file-logger.ts
+import { createWriteStream } from "fs";
+class FileLoggerSink {
+  config;
+  _stream;
+  _isClosed = false;
+  constructor(config) {
+    this.config = config;
+    this._stream = createWriteStream(config.path, {
+      flags: "a",
+      encoding: "utf8",
+      highWaterMark: config.bufferSize ?? 16 * 1024
+    });
+  }
+  async log(level, timestamp, object) {
+    if (this._isClosed)
+      return;
+    const logEntry = JSON.stringify({ timestamp, level, content: object }) + `
+`;
+    const canContinue = this._stream.write(logEntry);
+    if (!canContinue)
+      await new Promise((resolve) => {
+        this._stream.once("drain", resolve);
+      });
+  }
+  async close() {
+    if (this._isClosed)
+      return;
+    this._isClosed = true;
+    return new Promise((resolve, reject) => {
+      this._stream.end((err) => {
+        if (err)
+          reject(new BaseError(FILE_LOGGER_ERROR_KEYS.FAILED_TO_CLOSE_STREAM, err.message));
+        else
+          resolve();
+      });
+    });
+  }
+}
+export {
+  FileLoggerSink,
+  FILE_LOGGER_ERROR_KEYS,
+  DevNullLoggerSink,
+  ConsoleLoggerSink
+};

package/dist/modules/logger/types/index.js

@@ -0,0 +1 @@
+// @bun

package/dist/modules/logger/worker-logger.d.ts

@@ -0,0 +1 @@
+export declare const workerFunction: () => void;

package/dist/modules/mailer/enums/index.js

@@ -0,0 +1,7 @@
+// @bun
+import {
+  MAILER_ERROR_KEYS
+} from "../../../chunk-6w9ja96e.js";
+export {
+  MAILER_ERROR_KEYS
+};

package/dist/modules/mailer/index.js

@@ -0,0 +1,55 @@
+// @bun
+import {
+  MAILER_ERROR_KEYS
+} from "../../chunk-6w9ja96e.js";
+import {
+  BaseError
+} from "../../chunk-9cgzhc50.js";
+
+// source/modules/mailer/smtp.ts
+import { createTransport } from "nodemailer";
+class SMTP {
+  _config;
+  _transporter = null;
+  constructor(config) {
+    this._config = {
+      port: 587,
+      secure: false,
+      ...config
+    };
+  }
+  async connect() {
+    if (this._transporter)
+      throw new BaseError(MAILER_ERROR_KEYS.SMTP_ALREADY_CONNECTED);
+    this._transporter = createTransport({
+      host: this._config.host,
+      port: this._config.port,
+      secure: this._config.secure,
+      auth: {
+        user: this._config.credentials.user,
+        pass: this._config.credentials.pass
+      },
+      pool: true,
+      maxConnections: this._config.pool?.maxConnections ?? 5
+    });
+    try {
+      await this._transporter.verify();
+    } catch (error) {
+      throw new BaseError(MAILER_ERROR_KEYS.SMTP_CONNECTION_ERROR, error);
+    }
+  }
+  disconnect() {
+    if (this._transporter) {
+      this._transporter.close();
+      this._transporter = null;
+    }
+  }
+  async sendMail(options) {
+    if (!this._transporter)
+      throw new BaseError(MAILER_ERROR_KEYS.SMTP_NOT_CONNECTED);
+    return this._transporter.sendMail(options);
+  }
+}
+export {
+  SMTP
+};

package/dist/modules/mailer/types/index.js

@@ -0,0 +1 @@
+// @bun

package/dist/modules/repository/index.js

@@ -0,0 +1,12 @@
+// @bun
+import {
+  Repository
+} from "../../chunk-afyz8rg5.js";
+import"../../chunk-grfyngq0.js";
+import"../../chunk-4v86f7gp.js";
+import"../../chunk-7t524zqh.js";
+import"../../chunk-sqts8vyk.js";
+import"../../chunk-9cgzhc50.js";
+export {
+  Repository
+};

package/dist/modules/repository/repository.d.ts

@@ -1,6 +1,6 @@
 import type { Knex } from 'knex';
-import type { Table } from '#/modules/database/table';
-import type { StreamWithAsyncIterable } from '#/shared/types/stream-with-async-iterable';
+import type { Table } from '../../modules/database/table';
+import type { StreamWithAsyncIterable } from '../../shared/types/stream-with-async-iterable';
 import type { Filter } from './types/filter';
 import type { OrderByItem } from './types/order-by-item';
 import type { QueryOptions } from './types/query-options';

package/dist/modules/repository/types/index.js

@@ -0,0 +1 @@
+// @bun

package/dist/modules/repository/types/query-options.d.ts

@@ -1,4 +1,4 @@
-import type { HTTP_STATUS_CODES } from '#/errors/enums/http-status-codes';
+import type { HTTP_STATUS_CODES } from '../../../errors/enums/http-status-codes';
 import type { Filter } from './filter';
 import type { OrderByItem } from './order-by-item';
 import type { SelectedFields } from './selected-fields';

package/dist/modules/singleton-manager/enums/index.js

@@ -0,0 +1,7 @@
+// @bun
+import {
+  SINGLETON_MANAGER_ERROR_KEYS
+} from "../../../chunk-z0ct35ft.js";
+export {
+  SINGLETON_MANAGER_ERROR_KEYS
+};

package/dist/modules/singleton-manager/index.js

@@ -0,0 +1,9 @@
+// @bun
+import {
+  SingletonManager
+} from "../../chunk-fs3wm3p4.js";
+import"../../chunk-z0ct35ft.js";
+import"../../chunk-9cgzhc50.js";
+export {
+  SingletonManager
+};

package/dist/modules/totp/enums/index.js

@@ -0,0 +1,7 @@
+// @bun
+import {
+  TOTP_ERROR_KEYS
+} from "../../../chunk-9r5anep5.js";
+export {
+  TOTP_ERROR_KEYS
+};

package/dist/modules/totp/index.js

@@ -0,0 +1,104 @@
+// @bun
+import {
+  createCounterBuffer,
+  dynamicTruncation,
+  generateHmac
+} from "../../chunk-m3grz32t.js";
+import {
+  TOTP_ERROR_KEYS
+} from "../../chunk-9r5anep5.js";
+import {
+  BaseError
+} from "../../chunk-9cgzhc50.js";
+
+// source/modules/totp/hotp.ts
+import { webcrypto } from "crypto";
+var hotp = async (secret, counter, {
+  algorithm = "SHA-1",
+  digits = 6
+} = {}) => {
+  const counterBuffer = createCounterBuffer(counter);
+  const key = await webcrypto.subtle.importKey("raw", secret, { name: "HMAC", hash: algorithm }, false, ["sign"]);
+  const hmacArray = await generateHmac(key, counterBuffer);
+  return dynamicTruncation(hmacArray, digits);
+};
+// source/modules/totp/otp-auth-uri.ts
+var buildOtpAuthUri = ({
+  secretBase32,
+  label,
+  issuer,
+  algorithm = "SHA-1",
+  digits = 6,
+  period = 30
+}) => {
+  const encodedLabel = encodeURIComponent(label);
+  const encodedIssuer = issuer ? encodeURIComponent(issuer) : undefined;
+  let uri = `otpauth://totp/${encodedLabel}?secret=${secretBase32}`;
+  if (encodedIssuer)
+    uri += `&issuer=${encodedIssuer}`;
+  if (algorithm !== "SHA-1")
+    uri += `&algorithm=${algorithm}`;
+  if (digits !== 6)
+    uri += `&digits=${digits}`;
+  if (period !== 30)
+    uri += `&period=${period}`;
+  return uri;
+};
+var parseOtpAuthUri = (uri) => {
+  const url = new URL(uri);
+  if (url.protocol !== "otpauth:")
+    throw new BaseError(TOTP_ERROR_KEYS.INVALID_OTP_AUTH_URI);
+  if (url.hostname !== "totp")
+    throw new BaseError(TOTP_ERROR_KEYS.INVALID_OTP_AUTH_URI);
+  const label = decodeURIComponent(url.pathname.slice(1));
+  const secretBase32 = url.searchParams.get("secret");
+  if (!secretBase32)
+    throw new BaseError(TOTP_ERROR_KEYS.MISSING_SECRET);
+  const issuerParam = url.searchParams.get("issuer");
+  const issuer = issuerParam ? decodeURIComponent(issuerParam) : undefined;
+  const algorithm = url.searchParams.get("algorithm") || "SHA-1";
+  const digits = parseInt(url.searchParams.get("digits") || "6", 10);
+  const period = parseInt(url.searchParams.get("period") || "30", 10);
+  const result = {
+    secretBase32,
+    label,
+    algorithm,
+    digits,
+    period,
+    ...issuer && { issuer }
+  };
+  return result;
+};
+// source/modules/totp/totp.ts
+var totp = async (secret, {
+  algorithm = "SHA-1",
+  digits = 6,
+  period = 30,
+  now = Date.now()
+} = {}) => {
+  const timeStep = Math.floor(now / 1000 / period);
+  return hotp(secret, timeStep, { algorithm, digits });
+};
+var verifyTotp = async (secret, code, {
+  algorithm = "SHA-1",
+  digits = 6,
+  period = 30,
+  window = 0,
+  now = Date.now()
+} = {}) => {
+  const currentTimeStep = Math.floor(now / 1000 / period);
+  for (let i = -window;i <= window; ++i) {
+    const timeStep = currentTimeStep + i;
+    const expectedCode = await hotp(secret, timeStep, { algorithm, digits });
+    if (expectedCode === code)
+      return true;
+  }
+  return false;
+};
+export {
+  verifyTotp,
+  totp,
+  parseOtpAuthUri,
+  hotp,
+  buildOtpAuthUri
+};

package/dist/modules/totp/types/index.js

@@ -0,0 +1 @@
+// @bun