@mrxsys/mrx-core 2.11.0-1-and-276-20251029 → 2.11.0-1-develop-20251030

package/dist/modules/elysia/error/error.d.ts

@@ -21,7 +21,21 @@ export declare const error: Elysia<"", {
     macro: {};
     macroFn: {};
     parser: {};
-    response: {};
+    response: {
+        200: {
+            message: string;
+            content: any;
+        } | {
+            message: "mrx-core.error.not_found";
+            content?: never;
+        } | {
+            message: "mrx-core.error.parse";
+            content?: never;
+        } | {
+            message: "mrx-core.error.internal_server_error";
+            content?: never;
+        };
+    };
 }, {}, {
     derive: {};
     resolve: {};

package/dist/modules/elysia/error/index.js

@@ -21,51 +21,54 @@ var error = new Elysia({
 }).error({
   BaseError,
   HttpError
-}).onError(({ code, error: error2, set, status }) => {
+}).onError(({ code, error: error2, set }) => {
   set.headers["content-type"] = "application/json; charset=utf-8";
   switch (code) {
     case "HttpError":
-      status(error2.httpStatusCode, {
+      set.status = error2.httpStatusCode;
+      return {
         message: error2.message,
         content: error2.cause
-      });
-      break;
+      };
     case "BaseError":
-      status(500, {
-        message: ERROR_KEYS.CORE_ERROR_INTERNAL_SERVER_ERROR,
+      set.status = 500;
+      return {
+        message: error2.message,
         content: error2.cause
-      });
-      break;
+      };
     case "VALIDATION": {
-      status(422, {
-        on: error2.type,
-        errors: error2.all.map((e) => ({
-          path: e.path,
-          value: e.value,
-          summary: e.summary,
-          message: e.schema?.error,
-          schema: filterByKeyExclusion(e.schema, ["error"], true)
-        }))
-      });
-      break;
+      set.status = 422;
+      return {
+        message: ERROR_KEYS.CORE_ERROR_VALIDATION,
+        content: {
+          on: error2.type,
+          errors: error2.all.map((e) => ({
+            path: e.path,
+            value: e.value,
+            summary: e.summary,
+            message: e.schema?.error,
+            schema: filterByKeyExclusion(e.schema, ["error"], true)
+          }))
+        }
+      };
     }
     case "NOT_FOUND":
-      status(404, {
+      set.status = 404;
+      return {
         message: ERROR_KEYS.CORE_ERROR_NOT_FOUND
-      });
-      break;
+      };
     case "PARSE":
-      status(400, {
+      set.status = 400;
+      return {
         message: ERROR_KEYS.CORE_ERROR_PARSE
-      });
-      break;
+      };
     case "INTERNAL_SERVER_ERROR":
     case "UNKNOWN":
     default:
-      status(500, {
+      set.status = 500;
+      return {
         message: ERROR_KEYS.CORE_ERROR_INTERNAL_SERVER_ERROR
-      });
-      break;
+      };
   }
 }).as("global");
 export {

package/dist/modules/logger/index.js

@@ -9,6 +9,80 @@ 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;
@@ -51,7 +125,7 @@ class Logger extends TypedEventEmitter {
     this._batchTimeout = batchTimeout;
     this._autoEnd = autoEnd;
     this._flushOnBeforeExit = flushOnBeforeExit;
-    this._worker = new Worker(new URL("worker-logger.ts", import.meta.url).href, { type: "module" });
+    this._worker = new Worker(URL.createObjectURL(new Blob([`(${workerFunction.toString()})()`], { type: "application/javascript" })), { type: "module" });
     this._setupWorkerMessages();
     if (this._autoEnd)
       this._setupAutoEnd();

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mrxsys/mrx-core",
-	"version": "2.11.0-1-and-276-20251029",
+	"version": "2.11.0-1-develop-20251030",
 	"author": "Ruby",
 	"devDependencies": {
 		"@eslint/js": "^9.38.0",