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

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

@@ -0,0 +1,100 @@
+// @bun
+import {
+  MICROSERVICE_SUCCESS_KEYS
+} from "../../../chunk-0d0zd2yg.js";
+
+// source/modules/elysia/microservice/microservice.ts
+import { Elysia } from "elysia";
+import { existsSync } from "fs";
+import { platform } from "os";
+
+// source/modules/elysia/microservice/schemas/info.ts
+import { t } from "elysia";
+var infoResponse200Schema = t.Object({
+  message: t.String({
+    description: "Message",
+    example: "Microservice Information"
+  }),
+  content: t.Object({
+    author: t.String({
+      description: "Author",
+      example: "Ruby"
+    }),
+    name: t.String({
+      description: "Name",
+      example: "API"
+    }),
+    version: t.String({
+      description: "Version",
+      example: "1.0.0"
+    }),
+    description: t.String({
+      description: "Description",
+      example: "Is a microservice that provides a RESTful API for the application."
+    })
+  })
+});
+
+// source/modules/elysia/microservice/schemas/ping.ts
+import { t as t2 } from "elysia";
+var pingResponse200Schema = t2.Object({
+  message: t2.String({
+    description: "Message",
+    example: "pong"
+  })
+});
+
+// source/modules/elysia/microservice/microservice.ts
+var findPackageJson = (path) => {
+  const isWin = platform() === "win32";
+  const separator = isWin ? "\\" : "/";
+  if (isWin && /^[A-Z]:\\$/i.test(path) || !isWin && path === "/")
+    return "";
+  const packageJsonPath = path + separator + "package.json";
+  if (existsSync(packageJsonPath))
+    return packageJsonPath;
+  const pathParts = path.split(separator);
+  if (pathParts.length <= 1)
+    return "";
+  const newPath = pathParts.slice(0, -1).join(separator);
+  if (newPath === "")
+    return "";
+  return findPackageJson(newPath);
+};
+var packageJson = await import(findPackageJson(Bun.main));
+var microservice = new Elysia({
+  name: "microservicePlugin",
+  prefix: "/microservice",
+  detail: {
+    tags: ["Microservice"],
+    security: []
+  }
+}).model({
+  infoResponse200: infoResponse200Schema,
+  pingResponse200: pingResponse200Schema
+}).get("/ping", () => ({
+  message: MICROSERVICE_SUCCESS_KEYS.PING_RESPONSE
+}), {
+  detail: {
+    summary: "Ping",
+    description: "Ping the microservice to check if it is alive"
+  },
+  response: "pingResponse200"
+}).get("/info", () => ({
+  message: MICROSERVICE_SUCCESS_KEYS.INFO_RETRIEVED,
+  content: {
+    name: packageJson.default.name,
+    version: packageJson.default.version,
+    description: packageJson.default.description,
+    author: packageJson.default.author
+  }
+}), {
+  detail: {
+    summary: "Info",
+    description: "Get information about the microservice"
+  },
+  response: "infoResponse200"
+}).as("scoped");
+export {
+  microservice
+};

package/dist/modules/elysia/rate-limit/enums/index.js

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

package/dist/modules/elysia/rate-limit/index.js

@@ -0,0 +1,81 @@
+// @bun
+import {
+  RATE_LIMIT_ERROR_KEYS
+} from "../../../chunk-dre2fgj0.js";
+import {
+  MemoryStore
+} from "../../../chunk-e30paw8a.js";
+import"../../../chunk-xhhj1gvj.js";
+import {
+  HttpError
+} from "../../../chunk-7t524zqh.js";
+import"../../../chunk-sqts8vyk.js";
+import"../../../chunk-9cgzhc50.js";
+
+// source/modules/elysia/rate-limit/rate-limit.ts
+import { Elysia } from "elysia";
+var rateLimit = (store) => {
+  const restrictedRoutes = new Map;
+  store = store || new MemoryStore;
+  const rateLimitCheck = async (key, limit, window, set) => {
+    if (set.headers["X-RateLimit-Limit"])
+      return;
+    let count = await store.get(key) ?? 0;
+    if (count === 0) {
+      await store.set(key, 1, window);
+      count = 1;
+    } else {
+      count = await store.increment(key);
+    }
+    const remaining = Math.max(0, limit - count);
+    const resetTime = await store.ttl(key);
+    set.headers = {
+      "X-RateLimit-Limit": limit.toString(),
+      "X-RateLimit-Remaining": remaining.toString(),
+      "X-RateLimit-Reset": resetTime.toString()
+    };
+    if (count > limit) {
+      set.status = 429;
+      throw new HttpError(RATE_LIMIT_ERROR_KEYS.RATE_LIMIT_EXCEEDED, "TOO_MANY_REQUESTS", {
+        limit,
+        window,
+        remaining: 0,
+        reset: resetTime
+      });
+    }
+  };
+  return new Elysia({
+    name: "rateLimit",
+    seed: {
+      store
+    }
+  }).macro({
+    rateLimit: ({ limit, window }) => ({
+      transform: ({ request }) => {
+        const route = `${request.method}:${new URL(request.url).pathname}`;
+        if (!restrictedRoutes.has(route)) {
+          restrictedRoutes.set(route, { limit, window });
+        } else if (restrictedRoutes.has(route)) {
+          const existing = restrictedRoutes.get(route);
+          if (limit != existing.limit || window != existing.window)
+            restrictedRoutes.set(route, {
+              limit,
+              window
+            });
+        }
+      },
+      beforeHandle: async ({ set, request, server }) => {
+        const route = `${request.method}:${new URL(request.url).pathname}`;
+        if (restrictedRoutes.has(route)) {
+          const { limit: limit2, window: window2 } = restrictedRoutes.get(route);
+          const ip = request.headers.get("x-forwarded-for") || request.headers.get("x-real-ip") || server?.requestIP(request)?.address || "127.0.0.1";
+          const key = `ratelimit:${route}:${ip}`;
+          await rateLimitCheck(key, limit2, window2, set);
+        }
+      }
+    })
+  }).as("global");
+};
+export {
+  rateLimit
+};

package/dist/modules/elysia/rate-limit/rate-limit.d.ts

@@ -1,4 +1,4 @@
-import type { KvStore } from '#/modules/kv-store/types/kv-store';
+import type { KvStore } from '../../../modules/kv-store/types/kv-store';
 import { Elysia, type HTTPHeaders, type StatusMap } from 'elysia';
 import type { RateLimitOptions } from './types/rate-limit-options';
 /**

package/dist/modules/elysia/rate-limit/types/index.js

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

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

@@ -0,0 +1,11 @@
+// @bun
+import {
+  JWT_ERROR_KEYS
+} from "../../../chunk-9d3zvgp6.js";
+import {
+  PARSE_HUMAN_TIME_TO_SECONDS_ERROR_KEYS
+} from "../../../chunk-12qzn7jw.js";
+export {
+  PARSE_HUMAN_TIME_TO_SECONDS_ERROR_KEYS,
+  JWT_ERROR_KEYS
+};

package/dist/modules/jwt/index.js

@@ -0,0 +1,51 @@
+// @bun
+import {
+  JWT_ERROR_KEYS
+} from "../../chunk-9d3zvgp6.js";
+import {
+  parseHumanTimeToSeconds
+} from "../../chunk-eeb7yskp.js";
+import"../../chunk-12qzn7jw.js";
+import {
+  HttpError
+} from "../../chunk-7t524zqh.js";
+import"../../chunk-sqts8vyk.js";
+import"../../chunk-9cgzhc50.js";
+
+// source/modules/jwt/jwt.ts
+import {
+  SignJWT,
+  jwtVerify
+} from "jose";
+var signJWT = (secret, payload, expiration = Math.floor(Date.now() / 1000) + 60 * 15) => {
+  const exp = expiration instanceof Date ? Math.floor(expiration.getTime() / 1000) : typeof expiration === "number" ? expiration : Math.floor(Date.now() / 1000) + parseHumanTimeToSeconds(expiration);
+  if (exp <= Math.floor(Date.now() / 1000))
+    throw new HttpError(JWT_ERROR_KEYS.JWT_EXPIRATION_PASSED, "BAD_REQUEST");
+  const finalPayload = {
+    iss: "Core-Issuer",
+    sub: "",
+    aud: ["Core-Audience"],
+    jti: Bun.randomUUIDv7(),
+    nbf: Math.floor(Date.now() / 1000),
+    iat: Math.floor(Date.now() / 1000),
+    exp,
+    ...payload
+  };
+  try {
+    const jwt = new SignJWT(finalPayload).setProtectedHeader({ alg: "HS256", typ: "JWT" }).setIssuer(finalPayload.iss).setSubject(finalPayload.sub).setAudience(finalPayload.aud).setJti(finalPayload.jti).setNotBefore(finalPayload.nbf).setIssuedAt(finalPayload.iat).setExpirationTime(expiration).sign(new TextEncoder().encode(secret));
+    return jwt;
+  } catch (error) {
+    throw new HttpError(JWT_ERROR_KEYS.JWT_SIGN_ERROR, "INTERNAL_SERVER_ERROR", error);
+  }
+};
+var verifyJWT = async (token, secret) => {
+  try {
+    return await jwtVerify(token, new TextEncoder().encode(secret));
+  } catch {
+    return false;
+  }
+};
+export {
+  verifyJWT,
+  signJWT
+};

package/dist/modules/jwt/utils/index.js

@@ -0,0 +1,9 @@
+// @bun
+import {
+  parseHumanTimeToSeconds
+} from "../../../chunk-eeb7yskp.js";
+import"../../../chunk-12qzn7jw.js";
+import"../../../chunk-9cgzhc50.js";
+export {
+  parseHumanTimeToSeconds
+};

package/dist/modules/kv-store/bun-redis/bun-redis-store.d.ts

@@ -1,5 +1,5 @@
 import { type RedisOptions } from 'bun';
-import type { KvStore } from '#/modules/kv-store/types/kv-store';
+import type { KvStore } from '../../../modules/kv-store/types/kv-store';
 /**
  * Redis-based key-value store implementation using Bun's Redis client.
  *

package/dist/modules/kv-store/bun-redis/index.js

@@ -0,0 +1,84 @@
+// @bun
+import {
+  KV_STORE_ERROR_KEYS
+} from "../../../chunk-xhhj1gvj.js";
+import {
+  BaseError
+} from "../../../chunk-9cgzhc50.js";
+
+// source/modules/kv-store/bun-redis/bun-redis-store.ts
+var {RedisClient } = globalThis.Bun;
+class BunRedisStore {
+  _client;
+  constructor(url, options) {
+    this._client = new RedisClient(url, options);
+  }
+  async connect() {
+    try {
+      await this._client.connect();
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.CONNECTION_FAILED, e);
+    }
+  }
+  close() {
+    try {
+      this._client.close();
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.CLOSING_CONNECTION_FAILED, e);
+    }
+  }
+  async get(key) {
+    const value = await this._client.get(key);
+    if (value === null)
+      return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  async set(key, value, ttlSec) {
+    const serialized = typeof value === "string" ? value : JSON.stringify(value);
+    if (ttlSec)
+      await this._client.set(key, serialized, "EX", ttlSec);
+    else
+      await this._client.set(key, serialized);
+  }
+  async increment(key, amount) {
+    try {
+      const number = await this._client.incrby(key, amount ?? 1);
+      return number;
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER, e);
+    }
+  }
+  async decrement(key, amount) {
+    try {
+      const number = await this._client.decrby(key, amount ?? 1);
+      return number;
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER, e);
+    }
+  }
+  async del(key) {
+    const res = await this._client.del(key);
+    return res === 1;
+  }
+  async expire(key, ttlSec) {
+    const res = await this._client.expire(key, ttlSec);
+    return res === 1;
+  }
+  async ttl(key) {
+    const res = await this._client.ttl(key);
+    return res;
+  }
+  async clean() {
+    const keys = await this._client.keys("*");
+    if (keys.length === 0)
+      return 0;
+    return this._client.del(...keys);
+  }
+}
+export {
+  BunRedisStore
+};

package/dist/modules/kv-store/enums/index.js

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

package/dist/modules/kv-store/ioredis/index.js

@@ -0,0 +1,86 @@
+// @bun
+import {
+  KV_STORE_ERROR_KEYS
+} from "../../../chunk-xhhj1gvj.js";
+import {
+  BaseError
+} from "../../../chunk-9cgzhc50.js";
+
+// source/modules/kv-store/ioredis/ioredis-store.ts
+import { Redis } from "ioredis";
+class IoRedisStore {
+  _client;
+  constructor(options) {
+    this._client = new Redis({
+      ...options,
+      lazyConnect: true
+    });
+  }
+  async connect() {
+    try {
+      await this._client.connect();
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.CONNECTION_FAILED, e);
+    }
+  }
+  async close() {
+    try {
+      await this._client.quit();
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.CLOSING_CONNECTION_FAILED, e);
+    }
+  }
+  async get(key) {
+    const value = await this._client.get(key);
+    if (value === null)
+      return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+  async set(key, value, ttlSec) {
+    const serialized = typeof value === "string" ? value : JSON.stringify(value);
+    if (ttlSec)
+      await this._client.setex(key, ttlSec, serialized);
+    else
+      await this._client.set(key, serialized);
+  }
+  async increment(key, amount = 1) {
+    try {
+      const number = await this._client.incrby(key, amount);
+      return number;
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER, e);
+    }
+  }
+  async decrement(key, amount = 1) {
+    try {
+      const number = await this._client.decrby(key, amount);
+      return number;
+    } catch (e) {
+      throw new BaseError(KV_STORE_ERROR_KEYS.NOT_INTEGER, e);
+    }
+  }
+  async del(key) {
+    const result = await this._client.del(key);
+    return result === 1;
+  }
+  async expire(key, ttlSec) {
+    const result = await this._client.expire(key, ttlSec);
+    return result === 1;
+  }
+  ttl(key) {
+    return this._client.ttl(key);
+  }
+  async clean() {
+    const keys = await this._client.keys("*");
+    if (keys.length === 0)
+      return 0;
+    return this._client.del(...keys);
+  }
+}
+export {
+  IoRedisStore
+};

package/dist/modules/kv-store/ioredis/ioredis-store.d.ts

@@ -1,5 +1,5 @@
 import { type RedisOptions } from 'ioredis';
-import type { KvStore } from '#/modules/kv-store/types/kv-store';
+import type { KvStore } from '../../../modules/kv-store/types/kv-store';
 /**
  * Redis-based key-value store implementation using ioredis client.
  *

package/dist/modules/kv-store/memory/index.js

@@ -0,0 +1,9 @@
+// @bun
+import {
+  MemoryStore
+} from "../../../chunk-e30paw8a.js";
+import"../../../chunk-xhhj1gvj.js";
+import"../../../chunk-9cgzhc50.js";
+export {
+  MemoryStore
+};

package/dist/modules/kv-store/memory/memory-store.d.ts

@@ -1,4 +1,4 @@
-import type { KvStore } from '#/modules/kv-store/types/kv-store';
+import type { KvStore } from '../../../modules/kv-store/types/kv-store';
 /**
  * In-memory key-value store implementation with automatic cleanup of expired entries.
  *

package/dist/modules/kv-store/types/index.js

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import type { BaseError } from '#/errors/base-error';
+import type { BaseError } from '../../../errors/base-error';
 export interface LoggerEvent {
     onBeforeExitError: [BaseError<{
         error: Error;