@mrxsys/mrx-core 2.4.0 → 2.5.1

package/dist/logger/logger.d.ts

@@ -1,173 +0,0 @@
-import { TypedEventEmitter } from '../typedEventEmitter/typedEventEmitter';
-import type { LoggerEvent } from './events/loggerEvents';
-import type { BodiesIntersection } from './types/bodiesIntersection';
-import type { LoggerStrategy } from './types/loggerStrategy';
-import type { StrategyMap } from './types/strategyMap';
-/**
- * Logger provides a flexible, type-safe logging system that allows multiple strategies for log output.
- * The logger uses a transform stream to process log entries and execute the logging strategies.
- *
- * Logger extends the {@link TypedEventEmitter} class to emit typed events when an error occurs or when the logger ends.
- * The logger can log messages with different levels: error, warn, info, debug, and log.
- *
- * @template TStrategies - The map of strategy names to LoggerStrategy types.
- */
-export declare class Logger<TStrategies extends StrategyMap = {}> extends TypedEventEmitter<LoggerEvent> {
-    /**
-     * The map of strategies.
-     */
-    private readonly _strategies;
-    /**
-     * The transform stream for processing log entries.
-     */
-    private readonly _logStream;
-    /**
-     * The queue of pending log entries.
-     */
-    private readonly _pendingLogs;
-    /**
-     * The maximum number of pending logs.
-     * @defaultValue 10_000
-     */
-    private readonly _maxPendingLogs;
-    /**
-     * Flag to indicate if the logger is currently writing logs.
-     */
-    private _isWriting;
-    /**
-     * Construct a Logger.
-     *
-     * @template TStrategies - The map of strategy names to LoggerStrategy types.
-     * @param strategies - Initial strategies map.
-     * @param maxPendingLogs - Maximum number of logs in the queue (default: 10_000)
-     */
-    constructor(strategies?: TStrategies, maxPendingLogs?: number);
-    /**
-     * Register a new logging strategy.
-     *
-     * @template Key - The name of the strategy.
-     * @template Strategy - The strategy type.
-     *
-     * @throws ({@link CoreError}): If the strategy is already added. ({@link loggerErrorKeys.stategyAlreadyAdded})
-     *
-     * @returns A new Logger instance with the added strategy.
-     */
-    registerStrategy<Key extends string, Strategy extends LoggerStrategy>(name: Key, strategy: Strategy): Logger<TStrategies & Record<Key, Strategy>>;
-    /**
-     * Unregister a logging strategy.
-     *
-     * @template Key - The name of the strategy.
-     *
-     * @throws ({@link CoreError}): If the strategy is not found. ({@link loggerErrorKeys.strategyNotFound})
-     *
-     * @returns A new Logger instance without the removed strategy.
-     */
-    unregisterStrategy<Key extends keyof TStrategies>(name: Key): Logger<Omit<TStrategies, Key>>;
-    /**
-     * Register multiple strategies at once.
-     *
-     * @template TNew - The new strategies to add.
-     *
-     * @throws ({@link CoreError}): If any strategy is already added. ({@link loggerErrorKeys.stategyAlreadyAdded})
-     *
-     * @returns A new Logger instance with the added strategies.
-     */
-    registerStrategies<TNew extends [string, LoggerStrategy][] = [string, LoggerStrategy][]>(strategies: TNew): Logger<TStrategies & {
-        [K in TNew[number][0]]: Extract<TNew[number], [K, LoggerStrategy]>[1];
-    }>;
-    /**
-     * Unregister multiple strategies at once.
-     *
-     * @template Keys - The names of the strategies to remove.
-     *
-     * @throws ({@link CoreError}): If any strategy is not found. ({@link loggerErrorKeys.strategyNotFound})
-     *
-     * @returns A new Logger instance without the removed strategies.
-     */
-    unregisterStrategies<Keys extends Extract<keyof TStrategies, string>>(names: Keys[]): Logger<Omit<TStrategies, Keys>>;
-    /**
-     * Remove all strategies.
-     *
-     * @returns A new Logger instance without any strategies.
-     */
-    clearStrategies(): Logger;
-    /**
-     * Log an error message.
-     *
-     * @template SNames - The names of the strategies to use.
-     *
-     * @param object - The object to log. ({@link BodiesIntersection})
-     * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-     *
-     * @throws ({@link CoreError}): If no strategy is added. ({@link loggerErrorKeys.noStrategyAdded})
-     */
-    error<SNames extends (keyof TStrategies)[] = (keyof TStrategies)[]>(object: BodiesIntersection<TStrategies, SNames[number]>, strategiesNames?: SNames): void;
-    /**
-     * Log a warning message.
-     *
-     * @template SNames - The names of the strategies to use.
-     *
-     * @param object - The object to log. ({@link BodiesIntersection})
-     * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-     *
-     * @throws ({@link CoreError}): If no strategy is added. ({@link loggerErrorKeys.noStrategyAdded})
-     */
-    warn<SNames extends (keyof TStrategies)[] = (keyof TStrategies)[]>(object: BodiesIntersection<TStrategies, SNames[number]>, strategiesNames?: SNames): void;
-    /**
-     * Log an info message.
-     *
-     * @template SNames - The names of the strategies to use.
-     *
-     * @param object - The object to log. ({@link BodiesIntersection})
-     * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-     *
-     * @throws ({@link CoreError}): If no strategy is added. ({@link loggerErrorKeys.noStrategyAdded})
-     */
-    info<SNames extends (keyof TStrategies)[] = (keyof TStrategies)[]>(object: BodiesIntersection<TStrategies, SNames[number]>, strategiesNames?: SNames): void;
-    /**
-     * Log a debug message.
-     *
-     * @template SNames - The names of the strategies to use.
-     *
-     * @param object - The object to log. ({@link BodiesIntersection})
-     * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-     *
-     * @throws ({@link CoreError}): If no strategy is added. ({@link loggerErrorKeys.noStrategyAdded})
-     */
-    debug<SNames extends (keyof TStrategies)[] = (keyof TStrategies)[]>(object: BodiesIntersection<TStrategies, SNames[number]>, strategiesNames?: SNames): void;
-    /**
-     * Log a generic message.
-     *
-     * @template SNames - The names of the strategies to use.
-     *
-     * @param object - The object to log. ({@link BodiesIntersection})
-     * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-     *
-     * @throws ({@link CoreError}): If no strategy is added. ({@link loggerErrorKeys.noStrategyAdded})
-     */
-    log<SNames extends (keyof TStrategies)[] = (keyof TStrategies)[]>(object: BodiesIntersection<TStrategies, SNames[number]>, strategiesNames?: SNames): void;
-    /**
-     * Internal: execute all strategies for a log event.
-     *
-     * @template TLogObject - The type of the log object.
-     *
-     * @throws ({@link CoreError}): If a strategy throws. ({@link loggerErrorKeys.loggerStrategyError})
-     */
-    private _executeStrategies;
-    /**
-     * Internal: queue a log event and start writing if not already.
-     *
-     * @template TLogObject - The type of the log object.
-     *
-     * @param level - The log level. ({@link LogLevels})
-     * @param object - The object to log.
-     * @param strategiesNames - The names of the strategies to use. If not provided, all strategies will be used.
-     *
-     * @throws ({@link CoreError}): If no strategy is added. ({@link loggerErrorKeys.noStrategyAdded})
-     */
-    private _out;
-    /**
-     * Internal: process the log queue and emit 'end' when done.
-     */
-    private _writeLog;
-}

package/dist/logger/strategies/index.d.ts

@@ -1,2 +0,0 @@
-export * from './consoleLogger.ts';
-export * from './fileLogger.ts';

package/dist/logger/strategies/index.js

@@ -1,2 +0,0 @@
-// @bun
-import{d as f,e as m}from"../../chunk-1c7w5cx7.js";import"../../chunk-4w7nd4nw.js";export{m as FileLoggerStrategy,f as ConsoleLoggerStrategy};

package/dist/logger/types/index.d.ts

@@ -1,6 +0,0 @@
-export type * from './bodiesIntersection.ts';
-export type * from './loggerStrategy.ts';
-export type * from './logLevels.ts';
-export type * from './logStreamChunk.ts';
-export type * from './strategyBody.ts';
-export type * from './strategyMap.ts';

package/dist/mailer/enums/index.d.ts

@@ -1 +0,0 @@
-export * from './mailerErrorKeys';

package/dist/mailer/enums/index.js

@@ -1,2 +0,0 @@
-// @bun
-import{g as e}from"../../chunk-40pg2cqx.js";import"../../chunk-4w7nd4nw.js";export{e as mailerErrorKeys};

package/dist/mailer/enums/mailerErrorKeys.d.ts

@@ -1,8 +0,0 @@
-export declare const mailerErrorKeys: {
-    /** Error when failing to connect to SMTP server. */
-    readonly smtpConnectionError: "core.error.mailer.smtp.connection_error";
-    /** Error when SMTP server is not connected. */
-    readonly smtpNotConnected: "core.error.mailer.smtp.not_connected";
-    /** Error when SMTP server is already connected. */
-    readonly smtpAlreadyConnected: "core.error.mailer.smtp.already_connected";
-};

package/dist/mailer/index.d.ts

@@ -1 +0,0 @@
-export * from './smtp';

package/dist/mailer/index.js

@@ -1,2 +0,0 @@
-// @bun
-import{f as e}from"../chunk-h9er1sh5.js";import"../chunk-40pg2cqx.js";import"../chunk-z00b1r18.js";import"../chunk-4w7nd4nw.js";export{e as SMTP};

package/dist/mailer/types/index.d.ts

@@ -1,3 +0,0 @@
-export type * from './smtpCredentials';
-export type * from './smtpOptions';
-export type * from './smtpPoolOptions';

package/dist/repository/index.d.ts

@@ -1 +0,0 @@
-export * from './repository';

package/dist/repository/index.js

@@ -1,2 +0,0 @@
-// @bun
-import{na as e}from"../chunk-fnb68m68.js";import"../chunk-9hj714bv.js";import"../chunk-z00b1r18.js";import"../chunk-qndyhwdn.js";import"../chunk-4w7nd4nw.js";export{e as Repository};

package/dist/repository/repository.d.ts

@@ -1,378 +0,0 @@
-import type { Knex } from 'knex';
-import type { Table } from '../database/table';
-import type { StreamWithAsyncIterable } from '../utils/types/streamWithAsyncIterable';
-import type { AdvancedSearch } from './types/advancedSearch';
-import type { QueryOptions } from './types/queryOptions';
-import type { QueryOptionsExtendPagination } from './types/queryOptionsExtendPagination';
-import type { QueryOptionsExtendStream } from './types/queryOptionsExtendStream';
-/**
- * Provides a type-safe, extensible interface for database operations (CRUD, search, streaming) on a table.
- *
- * - Wraps Knex.js for query building and execution.
- * - Supports advanced search, pagination, field selection, and streaming.
- * - Centralizes error handling for MSSQL.
- *
- * @template TModel - The data model type handled by the repository.
- *
- * Example:
- * ```typescript
- * const repo = new Repository<User>(knex, userTable);
- * const users = await repo.find({ limit: 10 });
- * ```
- */
-export declare class Repository<TModel = unknown> {
-    /**
-     * The Knex instance used for database operations.
-     */
-    protected readonly _knex: Knex;
-    /**
-     * The table associated with this repository.
-     * @see {@link Table}
-     */
-    protected readonly _table: Table;
-    /**
-     * Creates a new `Repository` instance with the specified Knex.js instance and table object.
-     *
-     * @param knex - The Knex.js instance used to interact with the database.
-     * @param table - The table object representing the database table to interact with.
-     */
-    constructor(knex: Knex, table: Table);
-    /**
-     * Finds records in the database based on the specified query options and returns a stream
-     * for async iteration. This method is particularly useful when working with large datasets
-     * that would be inefficient to load entirely into memory.
-     *
-     * The stream emits data events for each record and an end event when the stream is finished.
-     * It can be consumed using either async iteration or event listeners.
-     *
-     * @template KModel - The type of the object to retrieve.
-     * @param options - The query options to apply to the search. ({@link QueryOptionsExtendStream})
-     *
-     * @returns A stream with an async iterable interface for consuming the results. ({@link StreamWithAsyncIterable})
-     *
-     *
-     * ### Usage Examples:
-     * @example
-     * ```typescript
-     * // Basic usage with async iteration
-     * const stream = userRepository.findStream();
-     * for await (const user of stream) {
-     *   console.log(user);
-     * }
-     *
-     * // With ordering and field selection
-     * const stream = userRepository.findStream({
-     *   selectedFields: ['id', 'name', 'email'],
-     *   orderBy: ['createdDate', 'desc']
-     * });
-     *
-     * // Using event listeners
-     * const stream = userRepository.findStream();
-     * stream.on('data', (user) => {
-     *   console.log('User:', user);
-     * });
-     * stream.on('error', (error) => {
-     *   console.error('Stream error:', error);
-     * });
-     * stream.on('end', () => {
-     *   console.log('Stream completed');
-     * });
-     *
-     * // With transform function to process records
-     * const stream = userRepository.findStream({
-     *   transform: (chunk, encoding, callback) => {
-     *     // Transform the data
-     *     const transformedData = { ...chunk, processed: true };
-     *     callback(null, transformedData);
-     *   }
-     * });
-     * ```
-     */
-    findStream<KModel extends TModel = NoInfer<TModel>>(options?: QueryOptionsExtendStream<KModel>): StreamWithAsyncIterable<KModel[]>;
-    /**
-     * Finds records in the database based on the specified query options and returns the results
-     * as an array. This method supports comprehensive filtering, pagination, field selection, and sorting
-     * to provide flexible data retrieval capabilities.
-     *
-     * @template KModel - The type of the object to retrieve.
-     * @param options - The query options to apply to the search. ({@link QueryOptionsExtendPagination})
-     *
-     * @throws ({@link CoreError}) Throws an error if no records are found and the `throwIfNoResult` option is enabled. ({@link databaseErrorKeys.mssqlNoResult})
-     * @throws ({@link CoreError}) Throws an error if an MSSQL-specific error occurs during the query execution. ({@link databaseErrorKeys})
-     *
-     * @returns An array of records matching the query options. ({@link KModel})
-     *
-     * ### Usage Examples:
-     * @example
-     * ```typescript
-     * // Basic usage with pagination
-     * const users = await userRepository.find({
-     *   limit: 25,
-     *   offset: 50  // Get users 51-75
-     * });
-     *
-     * // With field selection
-     * const userNames = await userRepository.find({
-     *   selectedFields: ['id', 'firstName', 'lastName']
-     * });
-     *
-     * // With advanced filtering
-     * const activeAdmins = await userRepository.find({
-     *   advancedSearch: {
-     *     role: 'admin',
-     *     status: { $eq: 'active' },
-     *     lastLogin: { $gte: new Date('2023-01-01') }
-     *   }
-     * });
-     *
-     * // With OR conditions
-     * const results = await userRepository.find({
-     *   advancedSearch: [
-     *     { department: 'engineering' },
-     *     { department: 'design', role: 'lead' }
-     *   ]
-     * });
-     *
-     * // With sorting
-     * const sortedUsers = await userRepository.find({
-     *   orderBy: ['lastName', 'asc']
-     * });
-     *
-     * // Using a transaction
-     * await knex.transaction(async (trx) => {
-     *   const users = await userRepository.find({
-     *     advancedSearch: { department: 'finance' },
-     *     transaction: trx
-     *   });
-     * });
-     * ```
-     */
-    find<KModel extends TModel = NoInfer<TModel>>(options?: QueryOptionsExtendPagination<KModel>): Promise<KModel[]>;
-    /**
-     * Finds a single record in the database based on the specified query options and returns the result.
-     * This method supports comprehensive filtering, field selection, and sorting to provide flexible data retrieval capabilities.
-     *
-     * @template KModel - The type of the object to retrieve.
-     * @param options - The query options to apply to the search. ({@link QueryOptionsExtendPagination})
-     *
-     * @throws ({@link CoreError}) Throws an error if no records are found and the `throwIfNoResult` option is enabled. ({@link databaseErrorKeys.mssqlNoResult})
-     * @throws ({@link CoreError}) Throws an error if an MSSQL-specific error occurs during the query execution. ({@link databaseErrorKeys})
-     *
-     * @returns A single record matching the query options. ({@link KModel})
-     *
-     * ### Usage Examples:
-     * @example
-     * ```typescript
-     * // Basic usage
-     * const user = await userRepository.findOne({
-     *   advancedSearch: { id: 1 }
-     * });
-     *
-     * // With field selection
-     * const user = await userRepository.findOne({
-     *   selectedFields: ['id', 'firstName', 'lastName'],
-     *   advancedSearch: { id: 1 }
-     * });
-     *
-     * // With advanced filtering
-     * const user = await userRepository.findOne({
-     *   advancedSearch: {
-     *     role: 'admin',
-     *     status: { $eq: 'active' },
-     *   }
-     * });
-     *
-     * // With sorting
-     * const user = await userRepository.findOne({
-     *   orderBy: ['lastName', 'asc']
-     * });
-     *
-     * // Using a transaction
-     * await knex.transaction(async (trx) => {
-     *   const user = await userRepository.findOne({
-     *       advancedSearch: { department: 'finance' },
-     *       transaction: trx
-     *   });
-     * });
-     * ```
-     */
-    findOne<KModel extends TModel = NoInfer<TModel>>(options: Omit<QueryOptions<KModel>, 'advancedSearch'> & Required<Pick<QueryOptions<KModel>, 'advancedSearch'>>): Promise<KModel>;
-    /**
-     * Counts the number of records in the database based on the specified query options.
-     * This method supports advanced search capabilities to filter the records before counting.
-     *
-     * @template KModel - The type of the object to count.
-     * @param options - The query options to apply to the search. ({@link QueryOptions})
-     *
-     * @throws ({@link CoreError}) Throws an error if no records are found and the `throwIfNoResult` option is enabled. ({@link databaseErrorKeys.mssqlNoResult})
-     * @throws ({@link CoreError}) Throws an error if an MSSQL-specific error occurs during the query execution. ({@link databaseErrorKeys})
-     *
-     * @returns The count of records matching the query options.
-     *
-     * ### Usage Examples:
-     * @example
-     * ```typescript
-     * // Basic usage
-     * const userCount = await userRepository.count();
-     *
-     * // With advanced filtering
-     * const activeUserCount = await userRepository.count({
-     *   advancedSearch: { status: 'active' }
-     * });
-     *
-     * // Using a transaction
-     * await knex.transaction(async (trx) => {
-     *   const userCount = await userRepository.count({
-     *       advancedSearch: { department: 'finance' },
-     *       transaction: trx
-     *   });
-     * });
-     * ```
-     */
-    count<KModel extends TModel = NoInfer<TModel>>(options?: Omit<QueryOptions<KModel>, 'selectedFields' | 'orderBy'>): Promise<number>;
-    /**
-     * Inserts new records into the database and returns the inserted records.
-     * This method supports bulk insertion of multiple records at once.
-     *
-     * @template KModel - The type of the object to insert.
-     * @param data - The data to insert. Can be a single object or an array of objects.
-     * @param options - The query options to apply to the insertion. ({@link QueryOptions})
-     *
-     * @throws ({@link CoreError}) Throws an error if an MSSQL-specific error occurs during the query execution. ({@link databaseErrorKeys})
-     *
-     * @returns An array of inserted records.
-     *
-     * ### Usage Examples:
-     * @example
-     * ```typescript
-     * // Basic usage
-     * const newUser = await userRepository.insert({ name: 'John Doe', email: 'john.doe@example.com' });
-     *
-     * // With bulk insertion
-     * const users = await userRepository.insert([
-     *   { name: 'Jane Doe', email: 'jane.doe@example.com' },
-     *   { name: 'John Smith', email: 'john.smith@example.com' }
-     * ]);
-     *
-     * // Using a transaction
-     * await knex.transaction(async (trx) => {
-     *   const newUser = await userRepository.insert({ name: 'John Doe', email: 'john.doe@example.com' }, {
-     *       transaction: trx
-     *   });
-     * });
-     * ```
-     */
-    insert<KModel extends TModel = NoInfer<TModel>>(data: Partial<KModel> | Partial<KModel>[], options?: Omit<QueryOptions<KModel>, 'advancedSearch' | 'orderBy'>): Promise<KModel[]>;
-    /**
-     * Updates existing records in the database based on the specified query options and returns the updated records.
-     * This method supports advanced search capabilities to filter the records before updating.
-     *
-     * @template KModel - The type of the object to update.
-     * @param data - The data to update. Can be a single object or an array of objects.
-     * @param options - The query options to apply to the update. ({@link QueryOptions})
-     *
-     * @throws ({@link CoreError}) Throws an error if an MSSQL-specific error occurs during the query execution. ({@link databaseErrorKeys})
-     *
-     * @returns An array of updated records.
-     *
-     * ### Usage Examples:
-     * @example
-     * ```typescript
-     * // Basic usage
-     * const updatedUser = await userRepository.update({ name: 'John Doe' }, {
-     *   advancedSearch: { id: 1 }
-     * });
-     *
-     * // With advanced filtering
-     * const updatedUsers = await userRepository.update({ status: 'inactive' }, {
-     *   advancedSearch: { role: 'admin' }
-     * });
-     *
-     * // Using a transaction
-     * await knex.transaction(async (trx) => {
-     *   const updatedUser = await userRepository.update({ name: 'John Doe' }, {
-     *       advancedSearch: { id: 1 },
-     *       transaction: trx
-     *   });
-     * });
-     * ```
-     */
-    update<KModel extends TModel = NoInfer<TModel>>(data: Partial<KModel>, options: Omit<QueryOptions<KModel>, 'orderBy' | 'advancedSearch'> & Required<Pick<QueryOptions<KModel>, 'advancedSearch'>>): Promise<KModel[]>;
-    /**
-     * Deletes records from the database based on the specified query options and returns the deleted records.
-     * This method supports advanced search capabilities to filter the records before deletion.
-     *
-     * @template KModel - The type of the object to delete.
-     * @param options - The query options to apply to the deletion. ({@link QueryOptions})
-     *
-     * @throws ({@link CoreError}) Throws an error if an MSSQL-specific error occurs during the query execution. ({@link databaseErrorKeys})
-     *
-     * @returns An array of deleted records.
-     *
-     * ### Usage Examples:
-     * @example
-     * ```typescript
-     * // Basic usage
-     * const deletedUser = await userRepository.delete({
-     *   advancedSearch: { id: 1 }
-     * });
-     *
-     * // With advanced filtering
-     * const deletedUsers = await userRepository.delete({
-     *   advancedSearch: { status: 'inactive' }
-     * });
-     *
-     * // Using a transaction
-     * await knex.transaction(async (trx) => {
-     *   const deletedUser = await userRepository.delete({
-     *       advancedSearch: { id: 1 },
-     *       transaction: trx
-     *   });
-     * });
-     * ```
-     */
-    delete<KModel extends TModel = NoInfer<TModel>>(options: Omit<QueryOptions<KModel>, 'orderBy' | 'advancedSearch'> & Required<Pick<QueryOptions<KModel>, 'advancedSearch'>>): Promise<KModel[]>;
-    /**
-     * Applies advanced search criteria to a Knex.js query builder. This method supports complex queries
-     * using operators like `$eq`, `$neq`, `$lt`, `$lte`, `$gt`, `$gte`, `$in`, `$nin`, `$between`, `$nbetween`,
-     * `$like`, `$nlike`, and `$isNull`. It also supports basic string searches and field selection.
-     *
-     * @template KModel - The type of the object to search for.
-     * @param query - The Knex.js query builder to apply the search criteria to. ({@link Knex.QueryBuilder})
-     * @param search - The advanced search criteria to apply. Can be a single object or an array of objects. ({@link AdvancedSearch})
-     */
-    protected _applySearch<KModel>(query: Knex.QueryBuilder, search: AdvancedSearch<KModel> | AdvancedSearch<KModel>[]): void;
-    /**
-     * Handles errors that occur during query execution. This method centralizes error handling
-     * for MSSQL-specific errors and throws a {@link CoreError} with relevant information.
-     *
-     * @param error - The error object thrown by Knex.js.
-     * @param query - The Knex.js query builder that caused the error.
-     *
-     * @throws ({@link CoreError}) Throws an error if an MSSQL-specific error occurs during the query execution. ({@link databaseErrorKeys})
-     *
-     * @returns Never returns, always throws an error.
-     */
-    protected _handleError(error: unknown, query: Knex.QueryBuilder): never;
-    /**
-     * Determines if the provided data is a complex query (i.e., a WhereClause).
-     *
-     * @param data - The data to check.
-     * @returns True if the data is a WhereClause, false otherwise.
-     */
-    private _isComplexQuery;
-    /**
-     * 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.
-     *
-     * @template KModel - The type of the records returned by the query.
-     * @param query - The Knex.js query builder to execute.
-     * @param throwIfNoResult - Whether to throw an error if no records are found.
-     *
-     * @throws ({@link CoreError}) Throws an error if no records are found and the `throwIfNoResult` option is enabled. ({@link databaseErrorKeys.mssqlNoResult})
-     * @throws ({@link CoreError}) Throws an error if an MSSQL-specific error occurs during the query execution. ({@link databaseErrorKeys})
-     *
-     * @returns An array of records returned by the query.
-     */
-    protected _executeQuery<KModel>(query: Knex.QueryBuilder, throwIfNoResult?: boolean): Promise<KModel[]>;
-}

package/dist/repository/types/advancedSearch.d.ts

@@ -1,47 +0,0 @@
-import type { WhereClause } from './whereClause';
-import type { SelectedFields } from './selectedFields';
-/**
- * Defines an advanced search model using either plain partials of the model T or a {@link WhereClause} filter for more dynamic querying.
- *
- * @template TModel - The model type to be used for the advanced search.
- *
- * @example
- * ```typescript
- * interface User {
- *    id: number;
- *   name: string;
- * }
- *
- * interface Basket {
- *   id: number;
- *   userId: number;
- *   products: Product[];
- * }
- *
- * const example1: AdvancedSearch<User> = {
- *     id: 1
- * };
- *
- * const example2: AdvancedSearch<User> = {
- *     name: {
- *         $eq: 'John'
- *     }
- * };
- *
- * const example3: AdvancedSearch<User> = {
- *    $q: 'John'
- * };
- *
- * const example4: AdvancedSearch<User & Basket> = {
- *   'basket.id': 1,
- * };
- * ```
- */
-export type AdvancedSearch<TModel> = {
-    $q?: string | number | {
-        selectedFields: SelectedFields<TModel>;
-        value: string | number;
-    };
-} & {
-    [Key in keyof TModel]?: TModel[Key] | Partial<WhereClause<TModel[Key]>>;
-};

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

@@ -1,8 +0,0 @@
-export type * from './advancedSearch';
-export type * from './orderBy';
-export type * from './queryOptions';
-export type * from './queryOptionsExtendPagination';
-export type * from './queryOptionsExtendStream';
-export type * from './selectedFields';
-export type * from './transaction';
-export type * from './whereClause';