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

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

@@ -51,7 +51,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(new URL("worker-logger.js", import.meta.url).href, { type: "module" });
     this._setupWorkerMessages();
     if (this._autoEnd)
       this._setupAutoEnd();

package/dist/modules/logger/worker-logger.js

@@ -0,0 +1,72 @@
+// @bun
+// source/modules/logger/worker-logger.ts
+var sinks = {};
+var self = globalThis;
+var 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;
+    }
+  }
+});

package/package.json

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