@mrxsys/mrx-core 2.11.0-1-and-269-20251003 → 2.11.1-1-and-275-20251023

package/dist/{chunk-dzfefxjq.js → chunk-pjv1ekwr.js}

@@ -35,6 +35,10 @@ var count = (database, tableName, {
     content: data
   };
 }, {
+  detail: {
+    summary: "Count",
+    description: `Count ${tableName} records based on query options.`
+  },
   ...getDbInjection(database),
   body: `${tableName}Count`,
   response: `${tableName}CountResponse200`,
@@ -63,6 +67,10 @@ var batchDelete = (database, tableName, {
     content: data
   };
 }, {
+  detail: {
+    summary: "Delete",
+    description: `Delete ${tableName} records based on query options.`
+  },
   ...getDbInjection(database),
   body: `${tableName}Delete`,
   response: `${tableName}Response200`,
@@ -96,6 +104,10 @@ var deleteOne = (database, tableName, {
     content: data
   };
 }, {
+  detail: {
+    summary: "Delete One",
+    description: `Delete a single ${tableName} record by its primary key.`
+  },
   ...getDbInjection(database),
   params: `${tableName}IdParam`,
   response: `${tableName}Response200`,
@@ -122,6 +134,10 @@ var find = (database, tableName, {
     content: data
   };
 }, {
+  detail: {
+    summary: "Find",
+    description: `Find ${tableName} records based on query options.`
+  },
   ...getDbInjection(database),
   body: `${tableName}Find`,
   response: `${tableName}Response200`,
@@ -154,6 +170,10 @@ var findOne = (database, tableName, {
     content: data
   };
 }, {
+  detail: {
+    summary: "Find One",
+    description: `Find a single ${tableName} record by its primary key.`
+  },
   ...getDbInjection(database),
   params: `${tableName}IdParam`,
   response: `${tableName}Response200`,
@@ -181,6 +201,10 @@ var insert = (database, tableName, {
     content: data
   };
 }, {
+  detail: {
+    summary: "Insert",
+    description: `Insert one or more records into the ${tableName} table.`
+  },
   ...getDbInjection(database),
   body: `${tableName}Insert`,
   response: `${tableName}Response200`,
@@ -208,6 +232,10 @@ var update = (database, tableName, {
     content: data
   };
 }, {
+  detail: {
+    summary: "Update",
+    description: `Update one or more ${tableName} records based on query options.`
+  },
   ...getDbInjection(database),
   body: `${tableName}Update`,
   response: `${tableName}Response200`,
@@ -242,6 +270,10 @@ var updateOne = (database, tableName, {
     content: data
   };
 }, {
+  detail: {
+    summary: "Update Single Record",
+    description: `Update a single record in the ${tableName} table by its primary key.`
+  },
   ...getDbInjection(database),
   params: `${tableName}IdParam`,
   body: `${tableName}UpdateOne`,

package/dist/chunk-rz5p4j3p.js

@@ -0,0 +1,13 @@
+// @bun
+// source/modules/logger/enums/logger-error-keys.ts
+var LOGGER_ERROR_KEYS = {
+  BEFORE_EXIT_CLOSE_ERROR: "mrx-core.logger.error.before_exit_close_error",
+  BEFORE_EXIT_FLUSH_ERROR: "mrx-core.logger.error.before_exit_flush_error",
+  NO_SINKS_PROVIDED: "mrx-core.logger.error.no_sinks_provided",
+  REGISTER_SINK_ERROR: "mrx-core.logger.error.register_sink_error",
+  SINK_ALREADY_ADDED: "mrx-core.logger.error.sink_already_added",
+  SINK_CLOSE_ERROR: "mrx-core.logger.error.sink_close_error",
+  SINK_LOG_ERROR: "mrx-core.logger.error.sink_log_error"
+};
+
+export { LOGGER_ERROR_KEYS };

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

@@ -1,12 +1,9 @@
 import { Elysia } from 'elysia';
-import { MemoryStore } from '../../../modules/kv-store/memory/memory-store';
+import type { KvStore } from '../../../modules/kv-store/types';
 import type { CacheOptions } from './types/cache-options';
-export declare const cache: ({ defaultTtl, prefix, store }?: CacheOptions) => Elysia<"", {
+export declare const cache: (store?: KvStore) => Elysia<"", {
     decorator: {};
-    store: {
-        kvStore: import("../../kv-store/types").KvStore | MemoryStore;
-        _cachedRoutes: Set<string>;
-    };
+    store: {};
     derive: {};
     resolve: {};
 }, {
@@ -16,11 +13,11 @@ export declare const cache: ({ defaultTtl, prefix, store }?: CacheOptions) => El
     schema: {};
     standaloneSchema: {};
     macro: Partial<{
-        readonly isCached: number | boolean;
+        readonly isCached: CacheOptions;
     }>;
     macroFn: {
-        readonly isCached: (enable: boolean | number) => {
-            readonly afterHandle: ({ set, responseValue, store, request }: {
+        readonly isCached: ({ ttl, prefix }: CacheOptions) => {
+            readonly afterHandle: ({ set, responseValue, request }: {
                 body: unknown;
                 query: Record<string, string>;
                 params: {};
@@ -37,10 +34,7 @@ export declare const cache: ({ defaultTtl, prefix, store }?: CacheOptions) => El
                 path: string;
                 route: string;
                 request: Request;
-                store: {
-                    kvStore: import("../../kv-store/types").KvStore | MemoryStore;
-                    _cachedRoutes: Set<string>;
-                };
+                store: {};
                 status: <const Code extends number | keyof import("elysia").StatusMap, const T = Code extends 100 | 101 | 102 | 103 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511 | 300 | 301 | 302 | 303 | 304 | 307 | 308 | 420 ? {
                     readonly 100: "Continue";
                     readonly 101: "Switching Protocols";

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

@@ -1,70 +1,90 @@
 // @bun
 import {
   MemoryStore
-} from "../../../chunk-e30paw8a.js";
+} from "../../kv-store/memory/index.js";
 import"../../../chunk-xhhj1gvj.js";
-import {
-  generateCacheKey
-} from "../../../chunk-b23dvm2d.js";
 import"../../../chunk-9cgzhc50.js";
 
 // source/modules/elysia/cache/cache.ts
 import { Elysia } from "elysia";
-var cache = ({
-  defaultTtl = 60,
-  prefix = "",
-  store = ":memory:"
-} = {}) => new Elysia().state({
-  kvStore: store === ":memory:" ? new MemoryStore : store
-}).state({
-  _cachedRoutes: new Set
-}).onRequest(async ({ request, store: store2, set }) => {
-  const sanitizeUrl = new URL(request.url).pathname;
-  if (store2._cachedRoutes.has(`${request.method}:${sanitizeUrl}`)) {
-    const cacheKey = await generateCacheKey(request.clone());
-    const cachedData = await store2.kvStore.get(`${prefix}${cacheKey}`);
-    if (cachedData && typeof cachedData === "object" && "response" in cachedData && "metadata" in cachedData) {
-      const { response, metadata } = cachedData;
-      set.headers["cache-control"] = `max-age=${metadata.ttl}, public`;
-      set.headers["x-cache"] = "HIT";
-      set.headers["etag"] = `"${prefix}${cacheKey}"`;
-      set.headers["expires"] = new Date(Date.now() + metadata.ttl * 1000).toUTCString();
-      set.headers["last-modified"] = metadata.createdAt;
-      if (response instanceof Response)
-        return response.clone();
-      return response;
+
+// source/modules/elysia/cache/utils/generate-cache-key.ts
+var _calculateBodyHash = async (body, hasher) => {
+  if (!body)
+    return;
+  const reader = body.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (value)
+        hasher.update(new Uint8Array(value));
     }
-    set.headers["x-cache"] = "MISS";
+  } finally {
+    reader.releaseLock();
   }
-  return;
-}).macro({
-  isCached: (enable) => {
-    const ttl = typeof enable === "number" ? enable : enable ? defaultTtl : 0;
-    return {
-      async afterHandle({ set, responseValue, store: store2, request }) {
-        const sanitizeUrl = new URL(request.url).pathname;
-        if (!store2._cachedRoutes.has(`${request.method}:${sanitizeUrl}`))
-          store2._cachedRoutes.add(`${request.method}:${sanitizeUrl}`);
+};
+var generateCacheKey = async (request) => {
+  const { method, url, headers } = request;
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(method);
+  hasher.update(url);
+  hasher.update(JSON.stringify(headers));
+  await _calculateBodyHash(request.body, hasher);
+  return hasher.digest("hex");
+};
+
+// source/modules/elysia/cache/cache.ts
+var cache = (store = new MemoryStore) => {
+  const cachedRoutes = new Map;
+  return new Elysia().onRequest(async ({ request, set }) => {
+    const route = `${request.method}:${new URL(request.url).pathname}`;
+    if (cachedRoutes.has(route)) {
+      const { ttl, prefix } = cachedRoutes.get(route);
+      const cacheKey = await generateCacheKey(request.clone());
+      const cacheItem = await store.get(`${prefix}${cacheKey}`);
+      if (cacheItem && typeof cacheItem === "object" && "response" in cacheItem && "metadata" in cacheItem) {
+        const createdAt = new Date(cacheItem.metadata.createdAt);
+        const expiresAt = new Date(createdAt.getTime() + ttl * 1000);
+        const now = Date.now();
+        const remaining = Math.max(0, Math.ceil((expiresAt.getTime() - now) / 1000));
+        set.headers["cache-control"] = `max-age=${remaining}, public`;
+        set.headers["etag"] = `"${prefix}${cacheKey}"`;
+        set.headers["last-modified"] = cacheItem.metadata.createdAt;
+        set.headers["expires"] = expiresAt.toUTCString();
+        set.headers["x-cache"] = "HIT";
+        if (cacheItem.response instanceof Response)
+          return cacheItem.response.clone();
+        return cacheItem.response;
+      }
+      set.headers["x-cache"] = "MISS";
+    }
+    return;
+  }).macro({
+    isCached: ({ ttl, prefix = "" }) => ({
+      async afterHandle({ set, responseValue, request }) {
+        const route = `${request.method}:${new URL(request.url).pathname}`;
+        if (!cachedRoutes.has(route))
+          cachedRoutes.set(route, { ttl, prefix });
         const cacheKey = await generateCacheKey(request.clone());
         const now = new Date;
         set.headers["cache-control"] = `max-age=${ttl}, public`;
         set.headers["etag"] = `"${prefix}${cacheKey}"`;
         set.headers["last-modified"] = now.toUTCString();
         set.headers["expires"] = new Date(now.getTime() + ttl * 1000).toUTCString();
-        if (!set.headers["x-cache"])
-          set.headers["x-cache"] = "MISS";
-        const cacheData = {
+        set.headers["x-cache"] = "MISS";
+        const cacheItem = {
           response: responseValue instanceof Response ? responseValue.clone() : responseValue,
           metadata: {
-            createdAt: now.toUTCString(),
-            ttl
+            createdAt: now.toUTCString()
           }
         };
-        await store2.kvStore.set(`${prefix}${cacheKey}`, cacheData, ttl);
+        await store.set(`${prefix}${cacheKey}`, cacheItem, ttl);
       }
-    };
-  }
-});
+    })
+  });
+};
 export {
   cache
 };

package/dist/modules/elysia/cache/types/cache-item.d.ts

@@ -2,6 +2,5 @@ export interface CacheItem {
     response: unknown;
     metadata: {
         createdAt: string;
-        ttl: number;
     };
 }

package/dist/modules/elysia/cache/types/cache-options.d.ts

@@ -1,21 +1,12 @@
-import type { KvStore } from '../../../../modules/kv-store/types/kv-store';
 export interface CacheOptions {
     /**
-     * Default TTL in seconds
-     *
-     * @defaultValue 60
+     * TTL in seconds
      */
-    defaultTtl?: number;
+    ttl: number;
     /**
      * Cache key prefix
      *
      * @defaultValue ''
      */
     prefix?: string;
-    /**
-     * Storage backend
-     *
-     * @defaultValue ':memory:'
-     */
-    store?: ':memory:' | KvStore;
 }

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

@@ -1,14 +1,4 @@
 // @bun
-import {
-  batchDelete,
-  count,
-  deleteOne,
-  find,
-  findOne,
-  insert,
-  update,
-  updateOne
-} from "../../../chunk-dzfefxjq.js";
 import {
   createCountResponse200Schema,
   createCountSchema,
@@ -21,6 +11,16 @@ import {
   createUpdateSchema
 } from "../../../chunk-p14h6jfs.js";
 import"../../../chunk-9dzsj7f2.js";
+import {
+  batchDelete,
+  count,
+  deleteOne,
+  find,
+  findOne,
+  insert,
+  update,
+  updateOne
+} from "../../../chunk-pjv1ekwr.js";
 import"../../../chunk-441xs5k1.js";
 import"../../../chunk-fs3wm3p4.js";
 import"../../../chunk-z0ct35ft.js";

package/dist/modules/elysia/crud/operations/index.js

@@ -8,7 +8,7 @@ import {
   insert,
   update,
   updateOne
-} from "../../../../chunk-dzfefxjq.js";
+} from "../../../../chunk-pjv1ekwr.js";
 import"../../../../chunk-441xs5k1.js";
 import"../../../../chunk-fs3wm3p4.js";
 import"../../../../chunk-z0ct35ft.js";

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

@@ -4,7 +4,7 @@ import {
 } from "../../../chunk-dre2fgj0.js";
 import {
   MemoryStore
-} from "../../../chunk-e30paw8a.js";
+} from "../../kv-store/memory/index.js";
 import"../../../chunk-xhhj1gvj.js";
 import {
   HttpError
@@ -14,40 +14,65 @@ import"../../../chunk-9cgzhc50.js";
 
 // source/modules/elysia/rate-limit/rate-limit.ts
 import { Elysia } from "elysia";
-var rateLimit = ({ store, limit, window }) => {
-  const storeInstance = store === ":memory:" || !store ? new MemoryStore : store;
-  return new Elysia({
-    name: "rateLimit",
-    seed: {
-      store,
-      limit,
-      window
-    }
-  }).onRequest(async ({ set, request, server }) => {
-    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:${ip}`;
-    const count = await storeInstance.get(key);
-    let newCount;
-    if (count === null) {
-      await storeInstance.set(key, 1, window);
-      newCount = 1;
+var rateLimit = (store = new MemoryStore) => {
+  const restrictedRoutes = new Map;
+  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 {
-      newCount = await storeInstance.increment(key);
+      count = await store.increment(key);
     }
-    if (newCount > limit) {
+    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: await storeInstance.ttl(key)
+        reset: resetTime
       });
     }
-    set.headers = {
-      "X-RateLimit-Limit": limit.toString(),
-      "X-RateLimit-Remaining": Math.max(0, limit - newCount).toString(),
-      "X-RateLimit-Reset": (await storeInstance.ttl(key)).toString()
-    };
+  };
+  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 {