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

package/dist/chunk-0d0zd2yg.js

@@ -0,0 +1,8 @@
+// @bun
+// source/modules/elysia/microservice/enums/microservice-success-keys.ts
+var MICROSERVICE_SUCCESS_KEYS = {
+  PING_RESPONSE: "mrx-core.microservice.success.ping_response",
+  INFO_RETRIEVED: "mrx-core.microservice.success.info_retrieved"
+};
+
+export { MICROSERVICE_SUCCESS_KEYS };

package/dist/chunk-12qzn7jw.js

@@ -0,0 +1,7 @@
+// @bun
+// source/modules/jwt/enums/parse-human-time-to-seconds-error-keys.ts
+var PARSE_HUMAN_TIME_TO_SECONDS_ERROR_KEYS = {
+  INVALID_TIME_EXPRESSION: "mrx-core.parse_human_time_to_seconds.error.invalid_time_expression"
+};
+
+export { PARSE_HUMAN_TIME_TO_SECONDS_ERROR_KEYS };

package/dist/chunk-441xs5k1.js

@@ -0,0 +1,53 @@
+// @bun
+import {
+  SingletonManager
+} from "./chunk-fs3wm3p4.js";
+import {
+  DB_RESOLVER_ERROR_KEYS
+} from "./chunk-8tffnbpn.js";
+import {
+  MSSQL
+} from "./chunk-afd82epa.js";
+import {
+  BaseError
+} from "./chunk-9cgzhc50.js";
+
+// source/modules/elysia/db-resolver/db-resolver.ts
+import { Elysia, t } from "elysia";
+var dbResolver = (prefixDatabaseName = "") => new Elysia().model({
+  dbResolverHeader: t.Object({
+    "database-using": t.String()
+  })
+}).macro({
+  injectDynamicDB(config) {
+    return {
+      headers: "dbResolverHeader",
+      async resolve({ headers }) {
+        const databaseName = headers["database-using"];
+        if (!SingletonManager.has(`${prefixDatabaseName}${databaseName}`)) {
+          SingletonManager.register(`${prefixDatabaseName}${databaseName}`, new MSSQL({
+            ...config,
+            databaseName
+          }));
+          await SingletonManager.get(`${prefixDatabaseName}${databaseName}`).connect();
+        }
+        return {
+          dynamicDB: SingletonManager.get(`${prefixDatabaseName}${databaseName}`)
+        };
+      }
+    };
+  },
+  injectStaticDB(databaseName) {
+    return {
+      resolve() {
+        if (!SingletonManager.has(`${prefixDatabaseName}${databaseName}`))
+          throw new BaseError(DB_RESOLVER_ERROR_KEYS.DB_RESOLVER_STATIC_DB_NOT_FOUND, `${prefixDatabaseName}${databaseName}`);
+        return {
+          staticDB: SingletonManager.get(`${prefixDatabaseName}${databaseName}`)
+        };
+      }
+    };
+  }
+});
+
+export { dbResolver };

package/dist/chunk-4v86f7gp.js

@@ -0,0 +1,59 @@
+// @bun
+// source/modules/database/enums/database-error-keys.ts
+var DATABASE_ERROR_KEYS = {
+  MSSQL_CONNECTION_ERROR: "mrx-core.mssql.error.database.connection_error",
+  MSSQL_DATABASE_ACCESS_DENIED: "mrx-core.mssql.error.database.access_denied",
+  MSSQL_DATABASE_AMBIGUOUS_COLUMN: "mrx-core.mssql.error.database.ambiguous_column",
+  MSSQL_DATABASE_AUTHORIZATION_FAILED: "mrx-core.mssql.error.database.authorization_failed",
+  MSSQL_DATABASE_COLUMN_NOT_FOUND: "mrx-core.mssql.error.database.column_not_found",
+  MSSQL_DATABASE_CONVERSION_FAILED: "mrx-core.mssql.error.database.conversion_failed",
+  MSSQL_DATABASE_DATA_TOO_LARGE: "mrx-core.mssql.error.database.data_too_large",
+  MSSQL_DATABASE_DEADLOCK_DETECTED: "mrx-core.mssql.error.database.deadlock_detected",
+  MSSQL_DATABASE_DUPLICATE_KEY: "mrx-core.mssql.error.database.duplicate_key",
+  MSSQL_DATABASE_FOREIGN_KEY_VIOLATION: "mrx-core.mssql.error.database.foreign_key_violation",
+  MSSQL_DATABASE_IDENTITY_INSERT_NOT_ALLOWED: "mrx-core.mssql.error.database.identity_insert_not_allowed",
+  MSSQL_DATABASE_INSUFFICIENT_MEMORY: "mrx-core.mssql.error.database.insufficient_memory",
+  MSSQL_DATABASE_INSUFFICIENT_STORAGE: "mrx-core.mssql.error.database.insufficient_storage",
+  MSSQL_DATABASE_PERMISSION_DENIED: "mrx-core.mssql.error.database.permission_denied",
+  MSSQL_DATABASE_QUERY_TIMEOUT: "mrx-core.mssql.error.database.query_timeout",
+  MSSQL_DATABASE_RESOURCE_LOCKED: "mrx-core.mssql.error.database.resource_locked",
+  MSSQL_DATABASE_SYNTAX_ERROR: "mrx-core.mssql.error.database.syntax_error",
+  MSSQL_DATABASE_TRANSACTION_ABORTED: "mrx-core.mssql.error.database.transaction_aborted",
+  MSSQL_DATABASE_TRANSACTION_LOG_FULL: "mrx-core.mssql.error.database.transaction_log_full",
+  MSSQL_DATABASE_UNIQUE_CONSTRAINT_VIOLATION: "mrx-core.mssql.error.database.unique_constraint_violation",
+  MSSQL_DATABASE_CANNOT_UPDATE_IDENTITY_COLUMN: "mrx-core.mssql.error.database.cannot_update_identity_column",
+  MSSQL_DISCONNECT_ERROR: "mrx-core.mssql.error.database.disconnect_error",
+  MSSQL_NO_RESULT: "mrx-core.mssql.error.database.no_result",
+  MSSQL_NOT_CONNECTED: "mrx-core.mssql.error.database.not_connected",
+  MSSQL_QUERY_ERROR: "mrx-core.mssql.error.database.query_error",
+  MSSQL_TABLE_NOT_FOUND: "mrx-core.mssql.error.database.table_not_found"
+};
+
+// source/modules/database/enums/mssql-error-code.ts
+var MSSQL_ERROR_CODE = {
+  0: DATABASE_ERROR_KEYS.MSSQL_QUERY_ERROR,
+  102: DATABASE_ERROR_KEYS.MSSQL_DATABASE_SYNTAX_ERROR,
+  1105: DATABASE_ERROR_KEYS.MSSQL_DATABASE_INSUFFICIENT_STORAGE,
+  1205: DATABASE_ERROR_KEYS.MSSQL_DATABASE_DEADLOCK_DETECTED,
+  1222: DATABASE_ERROR_KEYS.MSSQL_DATABASE_RESOURCE_LOCKED,
+  18452: DATABASE_ERROR_KEYS.MSSQL_DATABASE_AUTHORIZATION_FAILED,
+  18456: DATABASE_ERROR_KEYS.MSSQL_DATABASE_AUTHORIZATION_FAILED,
+  207: DATABASE_ERROR_KEYS.MSSQL_DATABASE_COLUMN_NOT_FOUND,
+  208: DATABASE_ERROR_KEYS.MSSQL_TABLE_NOT_FOUND,
+  209: DATABASE_ERROR_KEYS.MSSQL_DATABASE_AMBIGUOUS_COLUMN,
+  229: DATABASE_ERROR_KEYS.MSSQL_DATABASE_PERMISSION_DENIED,
+  2601: DATABASE_ERROR_KEYS.MSSQL_DATABASE_UNIQUE_CONSTRAINT_VIOLATION,
+  2627: DATABASE_ERROR_KEYS.MSSQL_DATABASE_DUPLICATE_KEY,
+  3928: DATABASE_ERROR_KEYS.MSSQL_DATABASE_TRANSACTION_ABORTED,
+  4060: DATABASE_ERROR_KEYS.MSSQL_DATABASE_ACCESS_DENIED,
+  544: DATABASE_ERROR_KEYS.MSSQL_DATABASE_IDENTITY_INSERT_NOT_ALLOWED,
+  547: DATABASE_ERROR_KEYS.MSSQL_DATABASE_FOREIGN_KEY_VIOLATION,
+  701: DATABASE_ERROR_KEYS.MSSQL_DATABASE_INSUFFICIENT_MEMORY,
+  8102: DATABASE_ERROR_KEYS.MSSQL_DATABASE_CANNOT_UPDATE_IDENTITY_COLUMN,
+  8152: DATABASE_ERROR_KEYS.MSSQL_DATABASE_DATA_TOO_LARGE,
+  8169: DATABASE_ERROR_KEYS.MSSQL_DATABASE_CONVERSION_FAILED,
+  8645: DATABASE_ERROR_KEYS.MSSQL_DATABASE_QUERY_TIMEOUT,
+  9002: DATABASE_ERROR_KEYS.MSSQL_DATABASE_TRANSACTION_LOG_FULL
+};
+
+export { DATABASE_ERROR_KEYS, MSSQL_ERROR_CODE };

package/dist/chunk-6w9ja96e.js

@@ -0,0 +1,9 @@
+// @bun
+// source/modules/mailer/enums/mailer-error-keys.ts
+var MAILER_ERROR_KEYS = {
+  SMTP_ALREADY_CONNECTED: "mrx-core.mailer.error.smtp.already_connected",
+  SMTP_CONNECTION_ERROR: "mrx-core.mailer.error.smtp.connection_error",
+  SMTP_NOT_CONNECTED: "mrx-core.mailer.error.smtp.not_connected"
+};
+
+export { MAILER_ERROR_KEYS };

package/dist/chunk-7t524zqh.js

@@ -0,0 +1,26 @@
+// @bun
+import {
+  HTTP_STATUS_CODES
+} from "./chunk-sqts8vyk.js";
+import {
+  BaseError
+} from "./chunk-9cgzhc50.js";
+
+// source/errors/http-error.ts
+class HttpError extends BaseError {
+  httpStatusCode;
+  constructor(message, a, b) {
+    const isStatus = typeof a === "number" || typeof a === "string" && a in HTTP_STATUS_CODES;
+    const status = isStatus ? typeof a === "number" ? a : HTTP_STATUS_CODES[a] : HTTP_STATUS_CODES.INTERNAL_SERVER_ERROR;
+    super(message, isStatus ? b : a);
+    this.httpStatusCode = status;
+  }
+  get isClientError() {
+    return this.httpStatusCode >= 400 && this.httpStatusCode < 500;
+  }
+  get isServerError() {
+    return this.httpStatusCode >= 500 && this.httpStatusCode < 600;
+  }
+}
+
+export { HttpError };

package/dist/chunk-8tffnbpn.js

@@ -0,0 +1,7 @@
+// @bun
+// source/modules/elysia/db-resolver/enums/db-resolver-error-keys.ts
+var DB_RESOLVER_ERROR_KEYS = {
+  DB_RESOLVER_STATIC_DB_NOT_FOUND: "mrx-core.db-resolver.error.static_db_not_found"
+};
+
+export { DB_RESOLVER_ERROR_KEYS };

package/dist/chunk-9cgzhc50.js

@@ -0,0 +1,15 @@
+// @bun
+// source/errors/base-error.ts
+class BaseError extends Error {
+  cause;
+  date = new Date;
+  constructor(message, cause) {
+    super(message, { cause });
+    this.cause = cause;
+    this.name = new.target.name;
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(this, new.target);
+  }
+}
+
+export { BaseError };

package/dist/chunk-9d3zvgp6.js

@@ -0,0 +1,9 @@
+// @bun
+// source/modules/jwt/enums/jwt-error-keys.ts
+var JWT_ERROR_KEYS = {
+  JWT_EXPIRATION_PASSED: "mrx-core.jwt.error.expiration_passed",
+  JWT_SECRET_NOT_FOUND: "mrx-core.jwt.error.secret_not_found",
+  JWT_SIGN_ERROR: "mrx-core.jwt.error.sign_error"
+};
+
+export { JWT_ERROR_KEYS };

package/dist/chunk-9dzsj7f2.js

@@ -0,0 +1,23 @@
+// @bun
+// source/shared/utils/flatten.ts
+import { KindGuard } from "@sinclair/typebox";
+import { t } from "elysia";
+var _flattenInto = (type, result) => {
+  if (KindGuard.IsUnion(type))
+    for (const subType of type.anyOf)
+      _flattenInto(subType, result);
+  else
+    result.push(type);
+};
+var flatten = (type) => {
+  if (!KindGuard.IsUnion(type))
+    return type;
+  const isAlreadyFlat = type.anyOf.every((subType) => !KindGuard.IsUnion(subType));
+  if (isAlreadyFlat)
+    return type;
+  const result = [];
+  _flattenInto(type, result);
+  return t.Union(result);
+};
+
+export { flatten };

package/dist/chunk-9r5anep5.js

@@ -0,0 +1,11 @@
+// @bun
+// source/modules/totp/enums/totp-error-keys.ts
+var TOTP_ERROR_KEYS = {
+  INVALID_ALGORITHM: "mrx-core.totp.error.invalid_algorithm",
+  INVALID_BASE32_CHARACTER: "mrx-core.totp.error.invalid_base32_character",
+  INVALID_OTP_AUTH_URI: "mrx-core.totp.error.invalid_otp_auth_uri",
+  INVALID_SECRET_LENGTH: "mrx-core.totp.error.invalid_secret_length",
+  MISSING_SECRET: "mrx-core.totp.error.missing_secret"
+};
+
+export { TOTP_ERROR_KEYS };

package/dist/chunk-afd82epa.js

@@ -0,0 +1,201 @@
+// @bun
+import {
+  Repository
+} from "./chunk-afyz8rg5.js";
+import {
+  TypedEventEmitter
+} from "./chunk-mvrxngm7.js";
+import {
+  DATABASE_ERROR_KEYS
+} from "./chunk-4v86f7gp.js";
+import {
+  BaseError
+} from "./chunk-9cgzhc50.js";
+
+// source/modules/database/table.ts
+class Table extends TypedEventEmitter {
+  _databaseName;
+  _fields = [];
+  _name;
+  _primaryKey;
+  constructor(databaseName, tableName, fields, primaryKey) {
+    super();
+    this._databaseName = databaseName;
+    this._name = tableName;
+    this._fields = fields;
+    this._primaryKey = primaryKey;
+  }
+  get databaseName() {
+    return this._databaseName;
+  }
+  get name() {
+    return this._name;
+  }
+  get fields() {
+    return this._fields;
+  }
+  get primaryKey() {
+    return this._primaryKey;
+  }
+}
+
+// source/modules/database/mssql.ts
+import knex from "knex";
+class MSSQL extends TypedEventEmitter {
+  _isConnected = false;
+  _databaseName;
+  _tables = new Map;
+  _repositories = new Map;
+  _db;
+  _isEventEnabled;
+  constructor(options) {
+    super();
+    this._databaseName = options.databaseName;
+    this._isEventEnabled = options.isEventEnabled ?? false;
+    this._db = knex({
+      client: "mssql",
+      acquireConnectionTimeout: options.connectionTimeout ?? 20000,
+      compileSqlOnError: true,
+      connection: {
+        database: options.databaseName,
+        host: options.host,
+        port: options.port,
+        user: options.user,
+        password: options.password,
+        options: {
+          encrypt: options.encrypt ?? true
+        },
+        bigNumberStrings: false
+      },
+      pool: {
+        min: options.poolMin ?? 2,
+        max: options.poolMax ?? 10
+      }
+    });
+  }
+  async connect() {
+    try {
+      await this._introspectDatabase();
+      this._isConnected = true;
+      if (this._isEventEnabled)
+        this._addEventKnex();
+    } catch (error) {
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_CONNECTION_ERROR, {
+        databaseName: this._databaseName,
+        error
+      });
+    }
+  }
+  async disconnect() {
+    if (!this._isConnected)
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_NOT_CONNECTED, {
+        databaseName: this._databaseName
+      });
+    try {
+      await this._db.destroy();
+      this._isConnected = false;
+    } catch (error) {
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_DISCONNECT_ERROR, {
+        databaseName: this._databaseName,
+        error
+      });
+    }
+  }
+  getRepository(tableName, customRepository) {
+    if (!this._isConnected)
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_NOT_CONNECTED, { databaseName: this._databaseName });
+    if (!this._tables.has(tableName))
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_TABLE_NOT_FOUND, { table: tableName });
+    let repo = this._repositories.get(tableName);
+    if (customRepository) {
+      const table = this._tables.get(tableName);
+      if (repo && repo instanceof customRepository)
+        return repo;
+      repo = new customRepository(this._db, table);
+      this._repositories.set(tableName, repo);
+      return repo;
+    }
+    return this._repositories.get(tableName);
+  }
+  getTable(tableName) {
+    if (!this._isConnected)
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_NOT_CONNECTED, { databaseName: this._databaseName });
+    if (!this._tables.has(tableName))
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_TABLE_NOT_FOUND, { table: tableName });
+    return this._tables.get(tableName);
+  }
+  get databaseName() {
+    return this._databaseName;
+  }
+  get tables() {
+    return this._tables;
+  }
+  get repositories() {
+    return this._repositories;
+  }
+  get isConnected() {
+    return this._isConnected;
+  }
+  get db() {
+    if (!this._isConnected)
+      throw new BaseError(DATABASE_ERROR_KEYS.MSSQL_NOT_CONNECTED, { databaseName: this._databaseName });
+    return this._db;
+  }
+  async _introspectDatabase() {
+    const result = await this._db.from({ c: "information_schema.columns" }).select("c.table_name as tableName").select(this._db.raw("STRING_AGG(c.column_name, ',') AS fields")).select("pk.primaryKeyColumn as primaryKeyColumn").select("pk.primaryKeyType as primaryKeyType").leftJoin(this._db.from({ tc: "information_schema.table_constraints" }).join({ kcu: "information_schema.key_column_usage" }, "tc.constraint_name", "kcu.constraint_name").join({ col: "information_schema.columns" }, (builder) => {
+      builder.on("col.table_name", "=", "kcu.table_name").andOn("col.column_name", "=", "kcu.column_name");
+    }).where("tc.constraint_type", "PRIMARY KEY").groupBy("tc.table_name", "kcu.column_name", "col.data_type").select("tc.table_name as tableName").select("kcu.column_name as primaryKeyColumn").select("col.data_type as primaryKeyType").as("pk"), "c.table_name", "pk.tableName").groupBy("c.table_name", "pk.primaryKeyColumn", "pk.primaryKeyType");
+    const fieldsByTable = result.reduce((acc, { tableName, fields, primaryKeyColumn, primaryKeyType }) => {
+      const primaryKeyTypeTs = primaryKeyType === "int" ? "NUMBER" : "STRING";
+      acc.set(tableName, {
+        fields: fields.split(","),
+        primaryKey: [primaryKeyColumn, primaryKeyTypeTs]
+      });
+      return acc;
+    }, new Map);
+    fieldsByTable.forEach((desc, tableName) => {
+      const table = new Table(this._databaseName, tableName, desc.fields, desc.primaryKey);
+      this._tables.set(tableName, table);
+      this._repositories.set(tableName, new Repository(this._db, table));
+    });
+  }
+  _extractTablesFromSqlQuery(sql) {
+    const tableRegex = /(?:update|insert\s+into|delete\s+from|from|join|with)\s+\[?([^\]\s]+)\]?/gi;
+    const matches = [...sql.matchAll(tableRegex)].map((match) => match[1]);
+    return Array.from(new Set(matches));
+  }
+  _handleQueryResponse(response, queryContext) {
+    const tables = this._extractTablesFromSqlQuery(queryContext.sql);
+    const table = this._tables.get(tables[0]);
+    switch (queryContext.method) {
+      case "select":
+        table?.emit("selected", response, queryContext);
+        break;
+      case "insert":
+        table?.emit("inserted", response, queryContext);
+        break;
+      case "update":
+        table?.emit("updated", response, queryContext);
+        break;
+      case "del":
+        table?.emit("deleted", response, queryContext);
+        break;
+      default:
+        break;
+    }
+  }
+  _addEventKnex() {
+    this._db.on("query", (queryContext) => {
+      this.emit("query", queryContext);
+    });
+    this._db.on("query-error", (error, queryContext) => {
+      this.emit("query:error", error, queryContext);
+    });
+    this._db.on("query-response", (response, queryContext) => {
+      this.emit("query:response", response, queryContext);
+      this._handleQueryResponse(response, queryContext);
+    });
+  }
+}
+
+export { Table, MSSQL };

package/dist/chunk-afyz8rg5.js

@@ -0,0 +1,209 @@
+// @bun
+import {
+  isDateString,
+  makeStreamAsyncIterable
+} from "./chunk-grfyngq0.js";
+import {
+  DATABASE_ERROR_KEYS,
+  MSSQL_ERROR_CODE
+} from "./chunk-4v86f7gp.js";
+import {
+  HttpError
+} from "./chunk-7t524zqh.js";
+
+// source/modules/repository/repository.ts
+import { PassThrough } from "stream";
+var _operators = {
+  $eq: (q, c, v) => q.where(c, v),
+  $neq: (q, c, v) => q.whereNot(c, v),
+  $lt: (q, c, v) => q.where(c, "<", v),
+  $lte: (q, c, v) => q.where(c, "<=", v),
+  $gt: (q, c, v) => q.where(c, ">", v),
+  $gte: (q, c, v) => q.where(c, ">=", v),
+  $in: (q, c, v) => q.whereIn(c, v),
+  $nin: (q, c, v) => q.whereNotIn(c, v),
+  $between: (q, c, v) => q.whereBetween(c, v),
+  $nbetween: (q, c, v) => q.whereNotBetween(c, v),
+  $like: (q, c, v) => {
+    const likeValue = `%${v}%`;
+    if (isDateString(v))
+      return q.whereRaw(`CONVERT(VARCHAR, ${c}, 23) LIKE ?`, [likeValue]);
+    return q.where(c, "LIKE", likeValue);
+  },
+  $nlike: (q, c, v) => {
+    const likeValue = `%${v}%`;
+    if (isDateString(v))
+      return q.whereRaw(`CONVERT(VARCHAR, ${c}, 23) NOT LIKE ?`, [likeValue]);
+    return q.whereRaw(`${c} NOT LIKE ?`, [likeValue]);
+  },
+  $isNull: (q, c, v) => v ? q.whereNull(c) : q.whereNotNull(c)
+};
+var _validOperatorKeys = new Set([
+  "$eq",
+  "$neq",
+  "$lt",
+  "$lte",
+  "$gt",
+  "$gte",
+  "$in",
+  "$nin",
+  "$between",
+  "$nbetween",
+  "$like",
+  "$nlike",
+  "$isNull"
+]);
+var _DEFAULT_LIMIT = 100;
+var _DEFAULT_OFFSET = 0;
+
+class Repository {
+  _knex;
+  _table;
+  constructor(knex, table) {
+    this._knex = knex;
+    this._table = table;
+  }
+  findStream(options) {
+    const query = this._knex(this._table.name);
+    this._applyQueryOptions(query, options);
+    const kStream = query.stream();
+    const passThrough = new PassThrough({
+      objectMode: true,
+      ...options?.transform && { transform: options.transform }
+    });
+    const cleanup = () => {
+      if (!kStream.destroyed)
+        kStream.destroy();
+      if (!passThrough.destroyed)
+        passThrough.destroy();
+    };
+    kStream.on("error", (error) => {
+      const code = error?.number || 0;
+      passThrough.emit("error", new HttpError(MSSQL_ERROR_CODE[code] ?? DATABASE_ERROR_KEYS.MSSQL_QUERY_ERROR, {
+        query: query.toSQL().sql,
+        error
+      }));
+    });
+    passThrough.on("close", cleanup);
+    passThrough.on("error", cleanup);
+    kStream.pipe(passThrough);
+    return makeStreamAsyncIterable(passThrough);
+  }
+  async find(options) {
+    const query = this._knex(this._table.name);
+    this._applyQueryOptions(query, options);
+    const limit = options?.limit || _DEFAULT_LIMIT;
+    const offset = options?.offset || _DEFAULT_OFFSET;
+    query.limit(limit).offset(offset);
+    return this._executeQuery(query, options?.throwIfNoResult);
+  }
+  async count(options) {
+    const query = this._knex(this._table.name).count({ count: "*" });
+    this._applyFilter(query, options?.filters);
+    if (options?.transaction)
+      query.transacting(options.transaction);
+    return this._executeQuery(query, options?.throwIfNoResult).then((result) => result[0].count);
+  }
+  async insert(data, options) {
+    const query = this._knex(this._table.name).insert(data).returning(options?.selectedFields ?? "*");
+    if (options?.transaction)
+      query.transacting(options.transaction);
+    return this._executeQuery(query);
+  }
+  async update(data, options) {
+    const query = this._knex(this._table.name).update(data);
+    this._applyQueryOptions(query, options);
+    return this._executeQuery(query, options?.throwIfNoResult);
+  }
+  async delete(options) {
+    const query = this._knex(this._table.name).delete();
+    this._applyQueryOptions(query, options);
+    return this._executeQuery(query, options?.throwIfNoResult);
+  }
+  _applySelectedFields(query, selectedFields) {
+    const qMethod = query._method;
+    const sanitizedFields = selectedFields ? selectedFields === "*" ? "*" : Array.isArray(selectedFields) ? selectedFields.map((selectedField) => `${selectedField} as ${selectedField}`) : `${selectedFields} as ${selectedFields}` : "*";
+    if (qMethod === "del" || qMethod === "update" || qMethod === "insert")
+      query.returning(sanitizedFields, { includeTriggerModifications: true });
+    else
+      query.select(sanitizedFields);
+  }
+  _applyFilter(query, search) {
+    const processing = (query2, search2) => {
+      for (const key in search2) {
+        const prop = search2[key];
+        if (this._filterIsAdaptiveWhereClause(prop)) {
+          for (const operator in prop)
+            if (operator in _operators && prop[operator] !== undefined)
+              _operators[operator](query2, key, prop[operator]);
+        } else if (key === "$q" && prop !== null && (typeof prop === "string" || typeof prop === "number")) {
+          for (const field of this._table.fields)
+            if (prop)
+              query2.orWhere(field, "like", `%${prop}%`);
+        } else if (key === "$q" && prop !== null && typeof prop === "object" && "selectedFields" in prop && "value" in prop) {
+          const { selectedFields, value } = prop;
+          if (Array.isArray(selectedFields))
+            for (const field of selectedFields)
+              query2.orWhere(field, "like", `%${value}%`);
+          else
+            query2.orWhere(selectedFields, "like", `%${value}%`);
+        } else {
+          if (prop !== null && typeof prop === "object" && Object.keys(prop).length === 0)
+            continue;
+          if (prop !== undefined)
+            query2.where(key, prop);
+        }
+      }
+    };
+    if (search && Array.isArray(search))
+      search.reduce((acc, item) => acc.orWhere((q) => this._applyFilter(q, item)), query);
+    else if (search)
+      processing(query, search);
+  }
+  _applyOrderBy(query, orderBy) {
+    const qMethod = query._method;
+    if (!(qMethod === "select"))
+      return;
+    if (!orderBy)
+      query.orderBy(`[${this._table.name}].${this._table.primaryKey[0]}`, "asc");
+    else if (Array.isArray(orderBy))
+      orderBy.forEach((item) => {
+        query.orderBy(`[${this._table.name}].${item.selectedField}`, item.direction);
+      });
+    else
+      query.orderBy(`[${this._table.name}].${orderBy.selectedField}`, orderBy.direction);
+  }
+  _applyQueryOptions(query, options) {
+    this._applyFilter(query, options?.filters);
+    this._applyOrderBy(query, options?.orderBy);
+    this._applySelectedFields(query, options?.selectedFields);
+    if (options?.transaction)
+      query.transacting(options.transaction);
+  }
+  _handleError(error, query) {
+    if (error instanceof HttpError)
+      throw error;
+    const code = error?.number || 0;
+    throw new HttpError(MSSQL_ERROR_CODE[code] ?? DATABASE_ERROR_KEYS.MSSQL_QUERY_ERROR, {
+      query: query.toSQL().sql,
+      error
+    });
+  }
+  _filterIsAdaptiveWhereClause(data) {
+    return Boolean(data && typeof data === "object" && !Array.isArray(data) && Object.keys(data).some((key) => _validOperatorKeys.has(key)));
+  }
+  async _executeQuery(query, throwIfNoResult = false) {
+    try {
+      const result = await query;
+      if (throwIfNoResult && result.length === 0)
+        throw new HttpError(typeof throwIfNoResult === "object" && throwIfNoResult.message ? throwIfNoResult.message : DATABASE_ERROR_KEYS.MSSQL_NO_RESULT, typeof throwIfNoResult === "object" && throwIfNoResult.httpStatusCode ? throwIfNoResult.httpStatusCode : 404, {
+          query: query.toSQL().sql
+        });
+      return result;
+    } catch (error) {
+      return this._handleError(error, query);
+    }
+  }
+}
+
+export { Repository };

package/dist/chunk-dre2fgj0.js

@@ -0,0 +1,7 @@
+// @bun
+// source/modules/elysia/rate-limit/enums/rate-limit-error-keys.ts
+var RATE_LIMIT_ERROR_KEYS = {
+  RATE_LIMIT_EXCEEDED: "mrx-core.elysia.rate-limit.error.exceeded"
+};
+
+export { RATE_LIMIT_ERROR_KEYS };