@mrxsys/mrx-core 2.4.0 → 2.5.1

package/dist/chunk-1a3wj3m1.js

@@ -0,0 +1,272 @@
+import {
+  isDateString,
+  makeStreamAsyncIterable
+} from "./chunk-5qtpggzv.js";
+import {
+  HttpError
+} from "./chunk-84mqvfsk.js";
+
+// source/modules/repository/repository.ts
+import { PassThrough } from "stream";
+
+// source/modules/database/enums/databaseErrorKeys.ts
+var DATABASE_ERROR_KEYS = {
+  MSSQL_CONNECTION_ERROR: "mssql.error.database.connection_error",
+  MSSQL_DISCONNECT_ERROR: "mssql.error.database.disconnect_error",
+  MSSQL_NOT_CONNECTED: "mssql.error.database.not_connected",
+  MSSQL_NO_RESULT: "mssql.error.database.no_result",
+  MSSQL_QUERY_ERROR: "mssql.error.database.query_error",
+  MSSQL_DATABASE_ACCESS_DENIED: "mssql.error.database.access_denied",
+  MSSQL_DATABASE_AUTHORIZATION8FAILED: "mssql.error.database.authorization_failed",
+  MSSQL_DATABASE_SYNTAX_ERROR: "mssql.error.database.syntax_error",
+  MSSQL_DATABASE_COLUMN_NOT_FOUND: "mssql.error.database.column_not_found",
+  MSSQL_TABLE_NOT_FOUND: "mssql.error.database.table_not_found",
+  MSSQL_DATABASE_AMBIGUOUS_COLUMN: "mssql.error.database.ambiguous_column",
+  MSSQL_DATABASE_DUPLICATE_KEY: "mssql.error.database.duplicate_key",
+  MSSQL_DATABASE_FOREIGN_KEY_VIOLATION: "mssql.error.database.foreign_key_violation",
+  MSSQL_DATABASE_UNIQUE_CONSTRAINT_VIOLATION: "mssql.error.database.unique_constraint_violation",
+  MSSQL_DATABASE_DEADLOCK_DETECTED: "mssql.error.database.deadlock_detected",
+  MSSQL_DATABASE_RESOURCE_LOCKED: "mssql.error.database.resource_locked",
+  MSSQL_DATABASE_TRANSACTION_ABORTED: "mssql.error.database.transaction_aborted",
+  MSSQL_DATABASE_INSUFFICIENT_MEMORY: "mssql.error.database.insufficient_memory",
+  MSSQL_DATABASE_INSUFFICIENT_STORAGE: "mssql.error.database.insufficient_storage",
+  MSSQL_DATABASE_QUERY_TIMEOUT: "mssql.error.database.query_timeout",
+  MSSQL_DATABASE_TRANSACTION_LOG_FULL: "mssql.error.database.transaction_log_full",
+  MSSQL_DATABASE_DATA_TOO_LARGE: "mssql.error.database.data_too_large",
+  MSSQL_DATABASE_PERMISSION_DENIED: "mssql.error.database.permission_denied",
+  MSSQL_DATABASE_IDENTITY_INSERT_NOT_ALLOWED: "mssql.error.database.identity_insert_not_allowed",
+  MSSQL_DATABSE_CANNOT_UPDATE_IDENTITY_COLUMN: "mssql.error.database.cannot_update_identity_column",
+  MSSQL_DATABASE_CONVERSION_FAILED: "mssql.error.database.conversion_failed"
+};
+
+// source/modules/database/enums/mssqlErrorCode.ts
+var MSSQL_ERROR_CODE = {
+  0: DATABASE_ERROR_KEYS.MSSQL_QUERY_ERROR,
+  4060: DATABASE_ERROR_KEYS.MSSQL_DATABASE_ACCESS_DENIED,
+  18452: DATABASE_ERROR_KEYS.MSSQL_DATABASE_AUTHORIZATION8FAILED,
+  18456: DATABASE_ERROR_KEYS.MSSQL_DATABASE_AUTHORIZATION8FAILED,
+  102: DATABASE_ERROR_KEYS.MSSQL_DATABASE_SYNTAX_ERROR,
+  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,
+  2627: DATABASE_ERROR_KEYS.MSSQL_DATABASE_DUPLICATE_KEY,
+  547: DATABASE_ERROR_KEYS.MSSQL_DATABASE_FOREIGN_KEY_VIOLATION,
+  2601: DATABASE_ERROR_KEYS.MSSQL_DATABASE_UNIQUE_CONSTRAINT_VIOLATION,
+  1205: DATABASE_ERROR_KEYS.MSSQL_DATABASE_DEADLOCK_DETECTED,
+  1222: DATABASE_ERROR_KEYS.MSSQL_DATABASE_RESOURCE_LOCKED,
+  3928: DATABASE_ERROR_KEYS.MSSQL_DATABASE_TRANSACTION_ABORTED,
+  701: DATABASE_ERROR_KEYS.MSSQL_DATABASE_INSUFFICIENT_MEMORY,
+  1105: DATABASE_ERROR_KEYS.MSSQL_DATABASE_INSUFFICIENT_STORAGE,
+  8645: DATABASE_ERROR_KEYS.MSSQL_DATABASE_QUERY_TIMEOUT,
+  9002: DATABASE_ERROR_KEYS.MSSQL_DATABASE_TRANSACTION_LOG_FULL,
+  8152: DATABASE_ERROR_KEYS.MSSQL_DATABASE_DATA_TOO_LARGE,
+  229: DATABASE_ERROR_KEYS.MSSQL_DATABASE_PERMISSION_DENIED,
+  544: DATABASE_ERROR_KEYS.MSSQL_DATABASE_IDENTITY_INSERT_NOT_ALLOWED,
+  8102: DATABASE_ERROR_KEYS.MSSQL_DATABSE_CANNOT_UPDATE_IDENTITY_COLUMN,
+  8169: DATABASE_ERROR_KEYS.MSSQL_DATABASE_CONVERSION_FAILED
+};
+
+// source/modules/repository/repository.ts
+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.whereLike(c, 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({
+        message: MSSQL_ERROR_CODE[code] ?? DATABASE_ERROR_KEYS.MSSQL_QUERY_ERROR,
+        cause: {
+          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);
+  }
+  async delete(options) {
+    const query = this._knex(this._table.name).delete();
+    this._applyQueryOptions(query, options);
+    return this._executeQuery(query);
+  }
+  _applySelectedFields(query, selectedFields) {
+    const qMethod = query._method;
+    if (qMethod === "del" || qMethod === "update" || qMethod === "insert")
+      query.returning(selectedFields ?? "*");
+    else
+      query.select(selectedFields ?? "*");
+  }
+  _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.primaryKey[0], "asc");
+    else if (Array.isArray(orderBy))
+      orderBy.forEach((item) => {
+        query.orderBy(item.selectedField, item.direction);
+      });
+    else
+      query.orderBy(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({
+      message: MSSQL_ERROR_CODE[code] ?? DATABASE_ERROR_KEYS.MSSQL_QUERY_ERROR,
+      cause: {
+        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({
+          message: DATABASE_ERROR_KEYS.MSSQL_NO_RESULT,
+          cause: {
+            query: query.toSQL().sql
+          },
+          httpStatusCode: 404
+        });
+      return result;
+    } catch (error) {
+      return this._handleError(error, query);
+    }
+  }
+}
+
+export { DATABASE_ERROR_KEYS, Repository };

package/dist/chunk-370444pc.js

@@ -0,0 +1,43 @@
+import {
+  BaseError
+} from "./chunk-vknq69e0.js";
+
+// source/modules/singletonManager/enums/singletonManagerErrorKeys.ts
+var SINGLETON_MANAGER_ERROR_KEYS = {
+  CLASS_CONSTRUCTOR_ALREADY_REGISTERED: "singletonManager.error.class_constructor_already_registered",
+  CLASS_CONSTRUCTOR_NOT_REGISTERED: "singletonManager.error.class_constructor_not_registered"
+};
+
+// source/modules/singletonManager/singletonManager.ts
+class SingletonManager {
+  static _registry = new Map;
+  static register(name, constructor, ...args) {
+    if (this._registry.has(name))
+      throw new BaseError({
+        message: SINGLETON_MANAGER_ERROR_KEYS.CLASS_CONSTRUCTOR_ALREADY_REGISTERED,
+        cause: { name }
+      });
+    this._registry.set(name, new constructor(...args));
+  }
+  static unregister(name) {
+    if (!this._registry.has(name))
+      throw new BaseError({
+        message: SINGLETON_MANAGER_ERROR_KEYS.CLASS_CONSTRUCTOR_NOT_REGISTERED,
+        cause: { name }
+      });
+    this._registry.delete(name);
+  }
+  static get(name) {
+    if (!this._registry.has(name))
+      throw new BaseError({
+        message: SINGLETON_MANAGER_ERROR_KEYS.CLASS_CONSTRUCTOR_NOT_REGISTERED,
+        cause: { name }
+      });
+    return this._registry.get(name);
+  }
+  static has(name) {
+    return this._registry.has(name);
+  }
+}
+
+export { SingletonManager };

package/dist/chunk-5qtpggzv.js

@@ -0,0 +1,38 @@
+// source/utils/isDateString.ts
+var isDateString = (v) => typeof v === "string" && new Date(v).toString() !== "Invalid Date";
+
+// source/utils/stream.ts
+var makeStreamAsyncIterable = (stream) => {
+  const asyncIterable = {
+    [Symbol.asyncIterator]: () => ({
+      next() {
+        return new Promise((resolve, reject) => {
+          const cleanup = () => {
+            stream.off("data", onData);
+            stream.off("end", onEnd);
+            stream.off("error", onError);
+          };
+          const onData = (data) => {
+            cleanup();
+            resolve({ value: data, done: false });
+          };
+          const onEnd = () => {
+            cleanup();
+            resolve({ value: undefined, done: true });
+          };
+          const onError = (error) => {
+            cleanup();
+            reject(error);
+          };
+          stream.on("data", onData);
+          stream.on("end", onEnd);
+          stream.on("error", onError);
+        });
+      }
+    })
+  };
+  stream[Symbol.asyncIterator] = asyncIterable[Symbol.asyncIterator];
+  return stream;
+};
+
+export { isDateString, makeStreamAsyncIterable };

package/dist/chunk-84mqvfsk.js

@@ -0,0 +1,69 @@
+import {
+  BaseError
+} from "./chunk-vknq69e0.js";
+
+// source/errors/enums/httpErrorStatusCodes.ts
+var HTTP_ERROR_STATUS_CODES = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  REQUEST_TIMEOUT: 408,
+  CONFLICT: 409,
+  GONE: 410,
+  LENGTH_REQUIRED: 411,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  URI_TOO_LONG: 414,
+  UNSUPPORTED_MEDIA_TYPE: 415,
+  RANGE_NOT_SATISFIABLE: 416,
+  EXPECTATION_FAILED: 417,
+  IM_A_TEAPOT: 418,
+  MISDIRECTED_REQUEST: 421,
+  UNPROCESSABLE_ENTITY: 422,
+  LOCKED: 423,
+  FAILED_DEPENDENCY: 424,
+  TOO_EARLY: 425,
+  UPGRADE_REQUIRED: 426,
+  PRECONDITION_REQUIRED: 428,
+  TOO_MANY_REQUESTS: 429,
+  REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+  UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+  HTTP_VERSION_NOT_SUPPORTED: 505,
+  VARIANT_ALSO_NEGOTIATES: 506,
+  INSUFFICIENT_STORAGE: 507,
+  LOOP_DETECTED: 508,
+  NOT_EXTENDED: 510,
+  NETWORK_AUTHENTICATION_REQUIRED: 511
+};
+
+// source/errors/httpError.ts
+class HttpError extends BaseError {
+  _httpStatusCode;
+  constructor(options) {
+    super(options);
+    super.name = "HttpError";
+    const statusCodeOption = options?.httpStatusCode;
+    this._httpStatusCode = typeof statusCodeOption === "number" ? statusCodeOption : HTTP_ERROR_STATUS_CODES[statusCodeOption ?? "INTERNAL_SERVER_ERROR"] ?? HTTP_ERROR_STATUS_CODES.INTERNAL_SERVER_ERROR;
+  }
+  get httpStatusCode() {
+    return this._httpStatusCode;
+  }
+  get isClientError() {
+    return this._httpStatusCode >= 400 && this._httpStatusCode < 500;
+  }
+  get isServerError() {
+    return this._httpStatusCode >= 500 && this._httpStatusCode < 600;
+  }
+}
+
+export { HttpError };

package/dist/chunk-cq973ydc.js

@@ -0,0 +1,82 @@
+import {
+  BaseError
+} from "./chunk-vknq69e0.js";
+
+// source/modules/data/enums/dataErrorKeys.ts
+var DATA_ERROR_KEYS = {
+  DATA_IS_NULL: "data.error.is_null"
+};
+
+// source/modules/data/data.ts
+var _validateDataNull = (data) => {
+  if (data === null || data === undefined)
+    throw new BaseError({
+      message: DATA_ERROR_KEYS.DATA_IS_NULL
+    });
+};
+var filterByKeyExclusion = (data, keys, excludeNullUndefined) => {
+  _validateDataNull(data);
+  const filteredData = {};
+  for (const key in data) {
+    const typedKey = key;
+    if (!keys.includes(typedKey) && (!excludeNullUndefined || data[typedKey] !== null && data[typedKey] !== undefined))
+      filteredData[key] = data[typedKey];
+  }
+  return filteredData;
+};
+var filterByKeyExclusionRecursive = (data, keys, excludeNullUndefined = false) => {
+  _validateDataNull(data);
+  const filteredData = {};
+  for (const key in data) {
+    const typedKey = key;
+    if (!keys.includes(typedKey) && (!excludeNullUndefined || data[typedKey] !== null && data[typedKey] !== undefined))
+      if (typeof data[typedKey] === "object" && data[typedKey] !== null && !Array.isArray(data[typedKey]))
+        filteredData[key] = filterByKeyExclusionRecursive(data[typedKey], keys, excludeNullUndefined);
+      else if (Array.isArray(data[typedKey]))
+        filteredData[key] = data[typedKey].map((item) => {
+          if (typeof item === "object" && item !== null && !Array.isArray(item))
+            return filterByKeyExclusionRecursive(item, keys, excludeNullUndefined);
+          return item;
+        });
+      else
+        filteredData[key] = data[typedKey];
+  }
+  for (const symbol of Object.getOwnPropertySymbols(data))
+    filteredData[symbol] = data[symbol];
+  return filteredData;
+};
+var filterByKeyInclusion = (data, keys, excludeNullUndefined, throwIfDataIsNull = true) => {
+  if (throwIfDataIsNull)
+    _validateDataNull(data);
+  const filteredData = {};
+  for (const key of keys) {
+    const typedKey = key;
+    if (typedKey in data && (!excludeNullUndefined || data[typedKey] !== null && data[typedKey] !== undefined))
+      filteredData[key] = data[typedKey];
+  }
+  return filteredData;
+};
+var filterByValue = (data, predicate, excludeNullUndefined = false, throwIfDataIsNull = true) => {
+  if (throwIfDataIsNull)
+    _validateDataNull(data);
+  const filteredData = {};
+  for (const key in data)
+    if (Object.hasOwn(data, key)) {
+      const typedKey = key;
+      if (predicate(data[typedKey]) && (!excludeNullUndefined || data[typedKey] !== null && data[typedKey] !== undefined))
+        filteredData[typedKey] = data[typedKey];
+    }
+  return filteredData;
+};
+var transformKeys = (data, transformer, throwIfDataIsNull = true) => {
+  if (throwIfDataIsNull)
+    _validateDataNull(data);
+  const result = {};
+  for (const key in data) {
+    const transformedKey = transformer.convertCase(key);
+    result[transformedKey] = data[key];
+  }
+  return result;
+};
+
+export { filterByKeyExclusion, filterByKeyExclusionRecursive, filterByKeyInclusion, filterByValue, transformKeys };