@mrxsys/mrx-core 2.11.0 → 2.12.0-1-and-288-20251203

package/dist/{chunk-sbpj7f3p.js → chunk-kne89z1w.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   Repository
-} from "./chunk-7j86h1nd.js";
+} from "./chunk-s53cbgkb.js";
 import {
   TypedEventEmitter
 } from "./chunk-mvrxngm7.js";

package/dist/{chunk-7j86h1nd.js → chunk-s53cbgkb.js}

@@ -139,21 +139,20 @@ class Repository {
     const processing = (query2, search2) => {
       for (const key in search2) {
         const prop = search2[key];
-        if (this._filterIsAdaptiveWhereClause(prop)) {
+        if (this._isAdaptiveWhereClause(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")) {
+        } else if (key === "$q" && this._isGlobalSearchPrimitive(prop)) {
           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 if (key === "$q" && this._isGlobalSearchObject(prop)) {
+          if (Array.isArray(prop.selectedFields))
+            for (const field of prop.selectedFields)
+              query2.orWhere(field, "like", `%${prop.value}%`);
           else
-            query2.orWhere(selectedFields, "like", `%${value}%`);
+            query2.orWhere(prop.selectedFields, "like", `%${prop.value}%`);
         } else {
           if (prop !== null && typeof prop === "object" && Object.keys(prop).length === 0)
             continue;
@@ -196,9 +195,15 @@ class Repository {
       error
     });
   }
-  _filterIsAdaptiveWhereClause(data) {
+  _isAdaptiveWhereClause(data) {
     return Boolean(data && typeof data === "object" && !Array.isArray(data) && Object.keys(data).some((key) => _validOperatorKeys.has(key)));
   }
+  _isGlobalSearchObject(data) {
+    return Boolean(data && typeof data === "object" && "selectedFields" in data && "value" in data);
+  }
+  _isGlobalSearchPrimitive(data) {
+    return data !== null && (typeof data === "string" || typeof data === "number");
+  }
   async _executeQuery(query, throwIfNoResult = false) {
     try {
       const result = await query;

package/dist/chunk-txazb0xn.js

@@ -0,0 +1,27 @@
+// @bun
+// source/modules/schema-builder/utils/is-date-from-elysia-typebox.ts
+import { KindGuard } from "@sinclair/typebox";
+var isDateFromElysiaTypeBox = (schema) => KindGuard.IsUnion(schema) && schema.anyOf.length === 4 && schema.anyOf.some((item) => KindGuard.IsDate(item)) && schema.anyOf.some((item) => KindGuard.IsString(item) && item.format === "date-time") && schema.anyOf.some((item) => KindGuard.IsString(item) && item.format === "date") && schema.anyOf.some((item) => KindGuard.IsNumber(item));
+
+// source/modules/schema-builder/utils/flatten.ts
+import { KindGuard as KindGuard2 } from "@sinclair/typebox";
+import { t } from "elysia";
+var _flattenInto = (type, result) => {
+  if (KindGuard2.IsUnion(type))
+    for (const subType of type.anyOf)
+      _flattenInto(subType, result);
+  else
+    result.push(type);
+};
+var flatten = (type) => {
+  if (!KindGuard2.IsUnion(type))
+    return type;
+  const isAlreadyFlat = type.anyOf.every((subType) => !KindGuard2.IsUnion(subType));
+  if (isAlreadyFlat)
+    return type;
+  const result = [];
+  _flattenInto(type, result);
+  return t.Union(result);
+};
+
+export { isDateFromElysiaTypeBox, flatten };

package/dist/modules/database/index.js

@@ -2,8 +2,8 @@
 import {
   MSSQL,
   Table
-} from "../../chunk-sbpj7f3p.js";
-import"../../chunk-7j86h1nd.js";
+} from "../../chunk-kne89z1w.js";
+import"../../chunk-s53cbgkb.js";
 import"../../chunk-grfyngq0.js";
 import"../../chunk-mvrxngm7.js";
 import"../../chunk-zv4ta4fb.js";

package/dist/modules/elysia/db-resolver/index.js

@@ -1,18 +1,61 @@
 // @bun
 import {
-  dbResolver
-} from "../../../chunk-yzgdqb02.js";
-import"../../../chunk-r7yr9p57.js";
+  SingletonManager
+} from "../../../chunk-r7yr9p57.js";
 import"../../../chunk-y5dtkmnp.js";
-import"../../../chunk-ayyrgqyv.js";
-import"../../../chunk-sbpj7f3p.js";
-import"../../../chunk-7j86h1nd.js";
+import {
+  DB_RESOLVER_ERROR_KEYS
+} from "../../../chunk-ayyrgqyv.js";
+import {
+  MSSQL
+} from "../../../chunk-kne89z1w.js";
+import"../../../chunk-s53cbgkb.js";
 import"../../../chunk-grfyngq0.js";
 import"../../../chunk-mvrxngm7.js";
 import"../../../chunk-zv4ta4fb.js";
 import"../../../chunk-sqts8vyk.js";
-import"../../../chunk-jz3wd472.js";
+import {
+  InternalError
+} from "../../../chunk-jz3wd472.js";
 import"../../../chunk-642xajvx.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 InternalError(DB_RESOLVER_ERROR_KEYS.DB_RESOLVER_STATIC_DB_NOT_FOUND, `${prefixDatabaseName}${databaseName}`);
+        return {
+          staticDB: SingletonManager.get(`${prefixDatabaseName}${databaseName}`)
+        };
+      }
+    };
+  }
+});
 export {
   dbResolver
 };

package/dist/modules/repository/index.js

@@ -1,7 +1,7 @@
 // @bun
 import {
   Repository
-} from "../../chunk-7j86h1nd.js";
+} from "../../chunk-s53cbgkb.js";
 import"../../chunk-grfyngq0.js";
 import"../../chunk-zv4ta4fb.js";
 import"../../chunk-sqts8vyk.js";

package/dist/modules/repository/repository.d.ts

@@ -2,7 +2,7 @@ import type { Knex } from 'knex';
 import type { Table } from '../../modules/database/table';
 import type { StreamWithAsyncIterable } from '../../shared/types/stream-with-async-iterable';
 import type { Filter } from './types/filter';
-import type { OrderByItem } from './types/order-by-item';
+import type { OrderBy } from './types/order-by';
 import type { QueryOptions } from './types/query-options';
 import type { QueryOptionsExtendPagination } from './types/query-options-extend-pagination';
 import type { QueryOptionsExtendStream } from './types/query-options-extend-stream';
@@ -373,7 +373,7 @@ export declare class Repository<TModel = Record<string, unknown>> {
      * @param query - The Knex.js query builder to apply the order by criteria to.
      * @param orderBy - The order by criteria. Can be a single item or an array of items.
      */
-    protected _applyOrderBy<KModel>(query: Knex.QueryBuilder, orderBy: OrderByItem<KModel> | OrderByItem<KModel>[] | undefined): void;
+    protected _applyOrderBy<KModel>(query: Knex.QueryBuilder, orderBy: OrderBy<KModel> | OrderBy<KModel>[] | undefined): void;
     /**
      * Applies query options such as filters, orderBy, and transaction to a Knex.js query builder.
      *
@@ -402,7 +402,23 @@ export declare class Repository<TModel = Record<string, unknown>> {
      *
      * @returns True if the data is a WhereClause, false otherwise.
      */
-    private _filterIsAdaptiveWhereClause;
+    private _isAdaptiveWhereClause;
+    /**
+     * Determines if the provided data is a QuickSearch object (excluding primitive types).
+     *
+     * @param data - The data to check.
+     *
+     * @returns True if the data is a QuickSearch object, false otherwise.
+     */
+    private _isGlobalSearchObject;
+    /**
+     * Determines if the provided data is a QuickSearch primitive (string or number).
+     *
+     * @param data - The data to check.
+     *
+     * @returns True if the data is a string or number, false otherwise.
+     */
+    private _isGlobalSearchPrimitive;
     /**
      * Executes a Knex.js query and returns the result. This method provides centralized
      * error handling and supports the option to throw an error if no records are found.

package/dist/modules/repository/types/filter.d.ts

@@ -1,5 +1,5 @@
 import type { AdaptiveWhereClause } from './adaptive-where-clause';
-import type { SelectedFields } from './selected-fields';
+import type { GlobalSearch } from './global-search';
 /**
  * Defines an filter model using either plain partials of the model TModel or a {@link AdaptiveWhereClause} filter for more dynamic querying.
  *
@@ -34,10 +34,7 @@ import type { SelectedFields } from './selected-fields';
  * ```
  */
 export type Filter<TModel> = {
-    $q?: string | number | {
-        selectedFields: SelectedFields<TModel>;
-        value: string | number;
-    };
+    $q?: GlobalSearch<TModel>;
 } & {
     [Key in keyof TModel]?: TModel[Key] | Partial<AdaptiveWhereClause<TModel[Key]>>;
 };

package/dist/modules/repository/types/global-search.d.ts

@@ -0,0 +1,12 @@
+import type { SelectedFields } from './selected-fields';
+/**
+ * Defines a global search filter that can search across one or multiple fields.
+ *
+ * @template TModel - The model type to search against.
+ */
+export type GlobalSearch<TModel> = string | number | {
+    /** Fields to search in. */
+    selectedFields: SelectedFields<TModel>;
+    /** The value to search for. */
+    value: string | number;
+};

package/dist/modules/repository/types/index.d.ts

@@ -1,8 +1,9 @@
 export type { AdaptiveWhereClause } from './adaptive-where-clause';
 export type { Filter } from './filter';
-export type { OrderByItem } from './order-by-item';
+export type { OrderBy } from './order-by';
 export type { QueryOptions } from './query-options';
 export type { QueryOptionsExtendPagination } from './query-options-extend-pagination';
 export type { QueryOptionsExtendStream } from './query-options-extend-stream';
+export type { GlobalSearch } from './global-search';
 export type { SelectedFields } from './selected-fields';
 export type { Transaction } from './transaction';

package/dist/modules/repository/types/{order-by-item.d.ts → order-by.d.ts}

@@ -16,7 +16,7 @@
  * @example
  * Order by a single field ascending
  * ```ts
- * const orderBy1: OrderByItem<User> = {
+ * const orderBy1: OrderBy<User> = {
  *   selectedField: 'id',
  *   direction: 'asc'
  * };
@@ -24,13 +24,13 @@
  * @example
  * Order by a single field descending
  * ```ts
- * const orderBy2: OrderByItem<User> = {
+ * const orderBy2: OrderBy<User> = {
  *   selectedField: 'name',
  *   direction: 'desc'
  * };
  * ```
  */
-export interface OrderByItem<TModel> {
+export interface OrderBy<TModel> {
     /**
      * The field to order by. Must be a key of the model or a string.
      */

package/dist/modules/repository/types/query-options.d.ts

@@ -1,6 +1,6 @@
 import type { HTTP_STATUS_CODES } from '../../../errors/enums/http-status-codes';
 import type { Filter } from './filter';
-import type { OrderByItem } from './order-by-item';
+import type { OrderBy } from './order-by';
 import type { SelectedFields } from './selected-fields';
 import type { Transaction } from './transaction';
 /**
@@ -10,21 +10,20 @@ import type { Transaction } from './transaction';
 */
 export interface QueryOptions<TModel> {
     /**
-     * The fields to select in the query. If not provided, all fields are selected. ({@link SelectedFields})
+     * The fields to select in the query. If not provided, all fields are selected.
      *
      * @defaultValue If not provided, all fields are selected.
      */
     readonly selectedFields?: SelectedFields<NoInfer<TModel>>;
     /**
      * The filters options to apply to the query. Can be a single object or an array of objects.
-     * @see {@link Filter}
      */
     readonly filters?: Filter<NoInfer<TModel>> | Filter<NoInfer<TModel>>[];
     /**
-     * Order the results by a specific column and direction. ({@link OrderByItem})
+     * Order the results by a specific column and direction.
      * @defaultValue If not provided, the primary key of the model is used in ascending order.
      */
-    readonly orderBy?: OrderByItem<NoInfer<TModel>> | OrderByItem<NoInfer<TModel>>[];
+    readonly orderBy?: OrderBy<NoInfer<TModel>> | OrderBy<NoInfer<TModel>>[];
     /**
      * Whether to throw an error if the query does not return any result.
      * @defaultValue false

package/dist/modules/schema-builder/build-adaptive-where-clause-schema.d.ts

@@ -0,0 +1,17 @@
+import { type TSchema } from '@sinclair/typebox/type';
+import type { AdaptiveWhereClauseSchema } from './types/adaptive-where-clause-schema';
+/**
+ * Build an AdaptiveWhereClauseSchema with appropriate operators based on the field type
+ *
+ * Generates different sets of query operators depending on the schema type:
+ * - All types: $eq, $neq, $isNull
+ * - String/Number/Date types: additional $in, $nin, $like, $nlike operators
+ * - Number/Date types: additional comparison operators ($lt, $lte, $gt, $gte, $between, $nbetween)
+ *
+ * @template TFieldSchema - The source object schema type.
+ *
+ * @param schema - The field schema to build the AdaptiveWhereClauseSchema for
+ *
+ * @returns An AdaptiveWhereClauseSchema
+ */
+export declare const buildAdaptiveWhereClauseSchema: <const TFieldSchema extends TSchema>(schema: TFieldSchema) => AdaptiveWhereClauseSchema<TFieldSchema>;

package/dist/modules/schema-builder/build-count-schema.d.ts

@@ -0,0 +1,12 @@
+import type { TObject } from '@sinclair/typebox/type';
+import type { CountSchema } from './types/count-schema';
+/**
+ * Build a CountSchema
+ *
+ * @template TSourceSchema - The TypeBox object schema to create count capabilities for
+ *
+ * @param schema - The source object schema type.
+ *
+ * @returns A CountSchema based on the provided schema
+ */
+export declare const buildCountSchema: <const TSourceCountSchema extends TObject>(schema: TSourceCountSchema) => CountSchema<TSourceCountSchema>;

package/dist/modules/{elysia/crud/utils/create-delete-schema.d.ts → schema-builder/build-delete-schema.d.ts}

@@ -1,7 +1,7 @@
 import type { TObject } from '@sinclair/typebox/type';
-import type { DeleteSchema } from '../../../../modules/elysia/crud/types/delete-schema';
+import type { DeleteSchema } from './types/delete-schema';
 /**
- * Creates a delete schema for deleting records with optional selected fields and required filtering.
+ * Creates a DeleteSchema.
  *
  * @template TSourceSchema - The TypeBox object schema to create delete capabilities for
  *
@@ -9,4 +9,4 @@ import type { DeleteSchema } from '../../../../modules/elysia/crud/types/delete-
  *
  * @returns A TypeBox object schema containing queryOptions with selected fields and filters for delete operations
  */
-export declare const createDeleteSchema: <TSourceDeleteSchema extends TObject>(schema: TSourceDeleteSchema) => DeleteSchema<TSourceDeleteSchema>;
+export declare const buildDeleteSchema: <TSourceDeleteSchema extends TObject>(schema: TSourceDeleteSchema) => DeleteSchema<TSourceDeleteSchema>;

package/dist/modules/schema-builder/build-filters-schema.d.ts

@@ -0,0 +1,12 @@
+import type { TObject } from '@sinclair/typebox/type';
+import type { FilterSchema } from './types/filter-schema';
+/**
+ * Build a FilterSchema for the given source object schema.
+ *
+ * @template TSourceSchema - The source object schema type.
+ *
+ * @param schema - The source object schema to build the FilterSchema for
+ *
+ * @returns A FilterSchema for the given source object schema
+ */
+export declare const buildFilterSchema: <const TSourceSchema extends TObject>(schema: TSourceSchema) => FilterSchema<TSourceSchema>;

package/dist/modules/schema-builder/build-find-schema.d.ts

@@ -0,0 +1,12 @@
+import type { TObject } from '@sinclair/typebox/type';
+import type { FindSchema } from './types/find-schema';
+/**
+ * Build a FindSchema.
+ *
+ * @template TSourceSchema - The source object schema type.
+ *
+ * @param schema - The base object schema to create search schemas for.
+ *
+ * @returns A TypeBox object schema for search with selected fields, order by, filters, limit, and offset
+ */
+export declare const buildFindSchema: <TSourceFindSchema extends TObject>(schema: TSourceFindSchema) => FindSchema<TSourceFindSchema>;

package/dist/modules/schema-builder/build-global-search-schema.d.ts

@@ -0,0 +1,12 @@
+import type { TObject } from '@sinclair/typebox/type';
+import type { GlobalSearchSchema } from './types/global-search-schema';
+/**
+ * Build a GlobalSearchSchema.
+ *
+ * @template TSourceSchema - The type of the source object schema
+ *
+ * @param schema - The source object schema type.
+ *
+ * @returns A GlobalSearchSchema
+ */
+export declare const buildGlobalSearchSchema: <const TSourceSchema extends TObject>(schema: TSourceSchema) => GlobalSearchSchema<TSourceSchema>;

package/dist/modules/schema-builder/build-insert-schema.d.ts

@@ -0,0 +1,3 @@
+import type { TObject } from '@sinclair/typebox/type';
+import type { InsertSchema } from './types/insert-schema';
+export declare const buildInsertSchema: <TSourceInsertSchema extends TObject>(schema: TSourceInsertSchema) => InsertSchema<TSourceInsertSchema>;

package/dist/modules/schema-builder/build-order-by-schema.d.ts

@@ -0,0 +1,12 @@
+import type { TObject } from '@sinclair/typebox/type';
+import type { OrderBySchema } from './types/order-by-schema';
+/**
+ * Build a OrderBySchema for the given source object schema.
+ *
+ * @template TSourceSchema - The source object schema type.
+ *
+ * @param schema - The source object schema to build the OrderBy schema for
+ *
+ * @returns A OrderBySchema for the given source object schema
+ */
+export declare const buildOrderBySchema: <const TSourceSchema extends TObject>(schema: TSourceSchema) => OrderBySchema<TSourceSchema>;

package/dist/modules/schema-builder/build-selected-fields.d.ts

@@ -0,0 +1,12 @@
+import type { TObject } from '@sinclair/typebox/type';
+import type { SelectedFieldsSchema } from './types/selected-fields-schema';
+/**
+ * Build a SelectSchema for selected fields based on a given object schema
+ *
+ * @template TSourceSchema - The source object schema type.
+ *
+ * @param schema - The source object schema to build the SelectSchema for
+ *
+ * @returns A SelectSchema that allows selecting keys of the source schema, the wildcard '*', or an array of keys
+ */
+export declare const buildSelectedFieldsSchema: <const TSourceSchema extends TObject>(schema: TSourceSchema) => SelectedFieldsSchema<TSourceSchema>;

package/dist/modules/schema-builder/build-update-one-schema.d.ts

@@ -0,0 +1,12 @@
+import type { TObject } from '@sinclair/typebox/type';
+import type { UpdateOneSchema } from './types/update-one-schema';
+/**
+ * Builds a UpdateOneSchema.
+ *
+ * @template TSourceUpdateSchema - The source object schema to build the update schema from.
+ *
+ * @param schema - The source object schema to build the update schema from.
+ *
+ * @returns A TypeBox object schema for updating a single record.
+ */
+export declare const buildUpdateOneSchema: <TSourceUpdateSchema extends TObject>(schema: TSourceUpdateSchema) => UpdateOneSchema<TSourceUpdateSchema>;

package/dist/modules/schema-builder/build-update-schema.d.ts

@@ -0,0 +1,12 @@
+import type { TObject } from '@sinclair/typebox/type';
+import type { UpdateSchema } from './types/update-schema';
+/**
+ * Builds an UpdateSchema.
+ *
+ * @template TSourceUpdateSchema - The TypeBox object schema to build the update schema from.
+ *
+ * @param schema - The source object schema to build the update schema from.
+ *
+ * @returns The update
+ */
+export declare const buildUpdateSchema: <TSourceUpdateSchema extends TObject>(schema: TSourceUpdateSchema) => UpdateSchema<TSourceUpdateSchema>;

package/dist/modules/schema-builder/clean-schema.d.ts

@@ -0,0 +1,2 @@
+import type { TObject } from '@sinclair/typebox';
+export declare const cleanSchema: <TSourceSchema extends TObject>(schema: TSourceSchema) => TSourceSchema;

package/dist/modules/schema-builder/index.d.ts

@@ -0,0 +1,12 @@
+export { buildAdaptiveWhereClauseSchema } from './build-adaptive-where-clause-schema';
+export { buildCountSchema } from './build-count-schema';
+export { buildDeleteSchema } from './build-delete-schema';
+export { buildFilterSchema } from './build-filters-schema';
+export { buildFindSchema } from './build-find-schema';
+export { buildGlobalSearchSchema } from './build-global-search-schema';
+export { buildInsertSchema } from './build-insert-schema';
+export { buildOrderBySchema } from './build-order-by-schema';
+export { buildSelectedFieldsSchema } from './build-selected-fields';
+export { buildUpdateOneSchema } from './build-update-one-schema';
+export { buildUpdateSchema } from './build-update-schema';
+export { cleanSchema } from './clean-schema';