@mrxsys/mrx-core 2.4.0 → 2.5.0

package/dist/chunk-vknq69e0.js

@@ -0,0 +1,23 @@
+// source/errors/baseError.ts
+import { randomUUID } from "crypto";
+
+class BaseError extends Error {
+  cause;
+  _uuid = randomUUID();
+  _date = new Date;
+  constructor(options) {
+    super(options?.message, {
+      cause: options?.cause
+    });
+    super.name = "BaseError";
+    this.cause = options?.cause;
+  }
+  get uuid() {
+    return this._uuid;
+  }
+  get date() {
+    return this._date;
+  }
+}
+
+export { BaseError };

package/dist/chunk-yvyahr2h.js

@@ -0,0 +1,40 @@
+// source/modules/typedEventEmitter/typedEventEmitter.ts
+import { EventEmitter } from "events";
+
+class TypedEventEmitter extends EventEmitter {
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  addListener(event, listener) {
+    return super.addListener(event, listener);
+  }
+  removeListener(event, listener) {
+    return super.removeListener(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  listenerCount(event) {
+    return super.listenerCount(event);
+  }
+  listeners(event) {
+    return super.listeners(event);
+  }
+  rawListeners(event) {
+    return super.rawListeners(event);
+  }
+  prependListener(event, listener) {
+    return super.prependListener(event, listener);
+  }
+  prependOnceListener(event, listener) {
+    return super.prependOnceListener(event, listener);
+  }
+}
+
+export { TypedEventEmitter };

package/dist/errors/baseError.d.ts

@@ -0,0 +1,9 @@
+import type { BaseErrorOptions } from './types/baseErrorOptions';
+export declare class BaseError<const TCause = unknown> extends Error {
+    readonly cause: TCause | undefined;
+    private readonly _uuid;
+    private readonly _date;
+    constructor(options?: Readonly<BaseErrorOptions<TCause>>);
+    get uuid(): string;
+    get date(): Date;
+}

package/dist/errors/enums/httpErrorStatusCodes.d.ts

@@ -0,0 +1,42 @@
+export declare const HTTP_ERROR_STATUS_CODES: {
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly PAYMENT_REQUIRED: 402;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly METHOD_NOT_ALLOWED: 405;
+    readonly NOT_ACCEPTABLE: 406;
+    readonly PROXY_AUTHENTICATION_REQUIRED: 407;
+    readonly REQUEST_TIMEOUT: 408;
+    readonly CONFLICT: 409;
+    readonly GONE: 410;
+    readonly LENGTH_REQUIRED: 411;
+    readonly PRECONDITION_FAILED: 412;
+    readonly PAYLOAD_TOO_LARGE: 413;
+    readonly URI_TOO_LONG: 414;
+    readonly UNSUPPORTED_MEDIA_TYPE: 415;
+    readonly RANGE_NOT_SATISFIABLE: 416;
+    readonly EXPECTATION_FAILED: 417;
+    readonly IM_A_TEAPOT: 418;
+    readonly MISDIRECTED_REQUEST: 421;
+    readonly UNPROCESSABLE_ENTITY: 422;
+    readonly LOCKED: 423;
+    readonly FAILED_DEPENDENCY: 424;
+    readonly TOO_EARLY: 425;
+    readonly UPGRADE_REQUIRED: 426;
+    readonly PRECONDITION_REQUIRED: 428;
+    readonly TOO_MANY_REQUESTS: 429;
+    readonly REQUEST_HEADER_FIELDS_TOO_LARGE: 431;
+    readonly UNAVAILABLE_FOR_LEGAL_REASONS: 451;
+    readonly INTERNAL_SERVER_ERROR: 500;
+    readonly NOT_IMPLEMENTED: 501;
+    readonly BAD_GATEWAY: 502;
+    readonly SERVICE_UNAVAILABLE: 503;
+    readonly GATEWAY_TIMEOUT: 504;
+    readonly HTTP_VERSION_NOT_SUPPORTED: 505;
+    readonly VARIANT_ALSO_NEGOTIATES: 506;
+    readonly INSUFFICIENT_STORAGE: 507;
+    readonly LOOP_DETECTED: 508;
+    readonly NOT_EXTENDED: 510;
+    readonly NETWORK_AUTHENTICATION_REQUIRED: 511;
+};

package/dist/errors/httpError.d.ts

@@ -0,0 +1,14 @@
+import { BaseError } from './baseError';
+import type { HttpErrorOptions } from './types/httpErrorOptions';
+/**
+ * Represents an HTTP error with a specific status code.
+ *
+ * @template TCause - The type of the cause of the error, if any.
+ */
+export declare class HttpError<const TCause = unknown> extends BaseError<TCause> {
+    private readonly _httpStatusCode;
+    constructor(options?: Readonly<HttpErrorOptions<TCause>>);
+    get httpStatusCode(): number;
+    get isClientError(): boolean;
+    get isServerError(): boolean;
+}

package/dist/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { BaseError } from './baseError';
+export { HttpError } from './httpError';

package/dist/errors/index.js

@@ -0,0 +1,11 @@
+// @bun
+import {
+  HttpError
+} from "../chunk-84mqvfsk.js";
+import {
+  BaseError
+} from "../chunk-vknq69e0.js";
+export {
+  HttpError,
+  BaseError
+};

package/dist/errors/types/baseErrorOptions.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Base options for all error types.
+ *
+ * @template TCause - The type of the cause of the error
+ */
+export interface BaseErrorOptions<TCause = unknown> {
+    /**
+     * The error message describing what went wrong
+     */
+    message?: string;
+    /**
+     * The cause of the error, typically another error or additional context
+     */
+    cause?: TCause;
+}

package/dist/errors/types/httpErrorOptions.d.ts

@@ -0,0 +1,13 @@
+import type { HTTP_ERROR_STATUS_CODES } from '../../errors/enums/httpErrorStatusCodes';
+import type { BaseErrorOptions } from './baseErrorOptions';
+/**
+ * Options for HTTP-related errors.
+ *
+ * @template TCause - The type of the cause of the error
+ */
+export interface HttpErrorOptions<TCause = unknown> extends BaseErrorOptions<TCause> {
+    /**
+     * The HTTP status code associated with the error
+     */
+    httpStatusCode?: keyof typeof HTTP_ERROR_STATUS_CODES | typeof HTTP_ERROR_STATUS_CODES[keyof typeof HTTP_ERROR_STATUS_CODES];
+}

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

@@ -0,0 +1,2 @@
+export type { BaseErrorOptions } from './baseErrorOptions';
+export type { HttpErrorOptions } from './httpErrorOptions';

package/dist/modules/data/data.d.ts

@@ -0,0 +1,115 @@
+import type { CaseTransformer } from './types/caseTransformer';
+import type { TransformObjectKeys } from './types/transformObjectKeys';
+/**
+ * Filters the provided data by excluding the specified keys.
+ *
+ * @template TObject - The type of the data object to filter, must be an object.
+ * @template TExcludedKeys - The keys to exclude from the data object.
+ * @template TExcludeNullUndefined - Boolean flag type to determine if properties with null or undefined values should be excluded.
+ *
+ * @param data - The data object to be filtered.
+ * @param keys - The array of keys to exclude from the data object. (Can be empty)
+ * @param excludeNullUndefined - Flag to determine if properties with null or undefined values should be excluded.
+ *
+ * @throws ({@link BaseError}) - Throws an error if the data is null or undefined.
+ *
+ * @returns The filtered data object with the specified keys excluded.
+ *
+ * @example
+ * Excludes the specified keys from the data object and returns a new object with the remaining properties.
+ * ```ts
+ * const object = { test: 'test', exclude: 'exclude' }; // type is { test: string, exclude: string }
+ * const filtered = filterByKeyExclusion(object, ['exclude']); // new type is { test: string }
+ * ```
+ * @example
+ * Excludes the specified keys from the data object and returns a new object with the remaining properties, excluding null or undefined values.
+ * ```ts
+ * const object = { test: 'test', exclude: 'exclude', nullValue: null, undefinedValue: undefined }; // type is { test: string, exclude: string, nullValue: null, undefinedValue: undefined }
+ * const filtered = filterByKeyExclusion(object, ['exclude'], true); // new type is { test: string }
+ * ```
+ */
+export declare const filterByKeyExclusion: <TObject extends Readonly<object>, TExcludedKeys extends keyof TObject = never, TExcludeNullUndefined extends boolean = false>(data: Readonly<TObject>, keys: readonly TExcludedKeys[], excludeNullUndefined?: TExcludeNullUndefined) => TExcludeNullUndefined extends true ? Partial<Omit<TObject, TExcludedKeys>> : Omit<TObject, TExcludedKeys>;
+/**
+ * Recursively filters the provided data by excluding the specified keys, with an option to exclude null or undefined values.
+ * The keys to exclude can be any valid property key and will be applied recursively to all nested objects.
+ *
+ * @template TObject - The type of the data object to filter, must be an object.
+ * @template TExcludedKeys - The keys to exclude from the data object and all nested objects.
+ *
+ * @param data - The data object to be filtered.
+ * @param keys - The array of keys to exclude from the data object and all nested objects. (Can be empty)
+ * @param excludeNullUndefined - Flag to determine if properties with null or undefined values should be excluded. Default is false.
+ *
+ * @throws ({@link BaseError}) - Throws an error if the data is null or undefined and throwIfDataIsNull is true.
+ *
+ * @returns A new object with the specified keys excluded recursively.
+ *
+ * @example
+ * ```typescript
+ * const object = { test: 'test', nested: { exclude: 'exclude', value: 'value' } };
+ * const filtered = filterByKeyExclusionRecursive(object, ['exclude']); // new type is { test: string, nested: { value: string } } (add third parameter to exclude null/undefined values)
+ * ```
+ */
+export declare const filterByKeyExclusionRecursive: <TObject extends Readonly<object>, TExcludedKeys extends PropertyKey = never>(data: Readonly<TObject>, keys: readonly TExcludedKeys[], excludeNullUndefined?: boolean) => Record<string, unknown>;
+/**
+ * Filters the provided data by including only the specified keys, with an option to exclude null or undefined values.
+ *
+ * @template TObject - The type of the data object to filter, must be an object.
+ * @template TIncludedKeys - The keys to include from the data object.
+ * @template TExcludeNullUndefined - Boolean flag type to determine if properties with null or undefined values should be excluded.
+ *
+ * @param data - The data object to be filtered.
+ * @param keys - The array of keys to include in the resulting data object. (Can be empty)
+ * @param excludeNullUndefined - Flag to determine if properties with null or undefined values should be excluded.
+ *
+ * @throws ({@link BaseError}) - Throws an error if the data is null or undefined.
+ *
+ * @returns The filtered data object with only the specified keys included.
+ *
+ * @example
+ * ```typescript
+ * const object = { test: 'test', exclude: 'exclude' }; // type is { test: string, exclude: string }
+ * const filtered = filterByKeyInclusion(object, ['test']); // new type is { test: string } (add third parameter to exclude null/undefined values)
+ * ```
+ */
+export declare const filterByKeyInclusion: <TObject extends Readonly<object>, TIncludedKeys extends keyof TObject = never, TExcludeNullUndefined extends boolean = false>(data: Readonly<TObject>, keys: readonly TIncludedKeys[], excludeNullUndefined?: TExcludeNullUndefined, throwIfDataIsNull?: boolean) => TExcludeNullUndefined extends true ? Partial<Pick<TObject, TIncludedKeys>> : Pick<TObject, TIncludedKeys>;
+/**
+ * Filters the provided data based on a predicate applied to its values. The resulting object
+ * will only include properties whose values satisfy the predicate function. Properties with
+ * null or undefined values can be optionally excluded based on the 'excludeNullUndefined' flag.
+ * @template TObject - The type of the data to be filtered, constrained to an object type.
+ *
+ * @param data - The data object to be filtered.
+ * @param predicate - The predicate function to apply to the values.
+ * @param excludeNullUndefined - Flag to determine if properties with null or undefined values should be excluded. Default is false.
+ *
+ * @throws ({@link BaseError}) - Throws an error if the data is null or undefined.
+ *
+ * @returns The filtered data object with properties satisfying the predicate.
+ *
+ * @example
+ * ```ts
+ * const object = { test: 'test', exclude: 'exclude' };
+ * const filtered = filterByValue(object, (value: unknown): boolean => value === 'test'); // you can also add third parameter to exclude null/undefined values
+ * ```
+ */
+export declare const filterByValue: <TObject extends Readonly<object>>(data: Readonly<TObject>, predicate: (value: TObject[keyof TObject]) => boolean, excludeNullUndefined?: boolean, throwIfDataIsNull?: boolean) => TObject;
+/**
+ * Transforms the keys of the given object using the current transformation strategy.
+ *
+ * @template TObject - The type of the object.
+ * @template TTransformer - The type of the key transformation strategy.
+ *
+ * @param data - The object whose keys are to be transformed.
+ * @param transformer - The key transformation strategy to use.
+ *
+ * @throws ({@link CoreError}) - If the provided data object is null or undefined.
+ *
+ * @returns A new object with transformed keys.
+ *
+ * @example
+ * ```ts
+ * transformKeys({ "my-key": "value" }, new CamelCaseTransformer()); // Returns { myKey: "value" }
+ * ```
+ */
+export declare const transformKeys: <TObject extends Readonly<Record<string, unknown>>, TTransformer extends CaseTransformer>(data: Readonly<TObject>, transformer: Readonly<TTransformer>, throwIfDataIsNull?: boolean) => TransformObjectKeys<TObject, TTransformer>;

package/dist/modules/data/enums/dataErrorKeys.d.ts

@@ -0,0 +1,3 @@
+export declare const DATA_ERROR_KEYS: {
+    readonly DATA_IS_NULL: "data.error.is_null";
+};

package/dist/modules/data/index.d.ts

@@ -0,0 +1 @@
+export { filterByKeyExclusion, filterByKeyInclusion, filterByKeyExclusionRecursive, filterByValue, transformKeys } from './data';

package/dist/modules/data/index.js

@@ -0,0 +1,16 @@
+// @bun
+import {
+  filterByKeyExclusion,
+  filterByKeyExclusionRecursive,
+  filterByKeyInclusion,
+  filterByValue,
+  transformKeys
+} from "../../chunk-cq973ydc.js";
+import"../../chunk-vknq69e0.js";
+export {
+  transformKeys,
+  filterByValue,
+  filterByKeyInclusion,
+  filterByKeyExclusionRecursive,
+  filterByKeyExclusion
+};

package/dist/modules/data/transformers/camelCase.d.ts

@@ -0,0 +1,25 @@
+import type { CamelCase } from '../../../modules/data/types/camelCase';
+import type { CaseTransformer } from '../../../modules/data/types/caseTransformer';
+/**
+ * Transforms string into `camelCase` format.
+ * Implements ({@link CaseTransformer}).
+ */
+export declare class CamelCaseTransformer implements CaseTransformer {
+    /**
+     * Transforms a string from any case to `camelCase`.
+     *
+     * @template S - The string type to be transformed.
+     *
+     * @param str - The string to transform into `camelCase`. {@link S}
+     *
+     * @returns The string transformed into `camelCase`.
+     *
+     * @example
+     * convertCase('MyKeyName'); // "myKeyName"
+     * @example
+     * convertCase('my-key-name'); // "myKeyName"
+     * @example
+     * convertCase('my_key_name'); // "myKeyName"
+     */
+    convertCase<S extends string>(str: S): CamelCase<S>;
+}

package/dist/modules/data/transformers/index.d.ts

@@ -0,0 +1,4 @@
+export { CamelCaseTransformer } from './camelCase.ts';
+export { KebabCaseTransformer } from './kebabCase.ts';
+export { PascalCaseTransformer } from './pascalCase.ts';
+export { SnakeCaseTransformer } from './snakeCase.ts';

package/dist/modules/data/transformers/index.js

@@ -0,0 +1,32 @@
+// @bun
+// source/modules/data/transformers/camelCase.ts
+class CamelCaseTransformer {
+  convertCase(str) {
+    return str.replace(/(?:[-_][a-z])/giu, (group) => group[1].toUpperCase()).replace(/^[A-Z]/u, (firstLetter) => firstLetter.toLowerCase());
+  }
+}
+// source/modules/data/transformers/kebabCase.ts
+class KebabCaseTransformer {
+  convertCase(str) {
+    return str.replace(/_/gu, "-").replace(/(?<=[a-z])(?=[A-Z])/gu, "-").replace(/(?<=[A-Z]+)(?=[A-Z][a-z])/gu, "-").toLowerCase();
+  }
+}
+// source/modules/data/transformers/pascalCase.ts
+class PascalCaseTransformer {
+  convertCase(str) {
+    const camelCaseKey = str.replace(/(?:[-_][a-z])/giu, (group) => group[1].toUpperCase());
+    return camelCaseKey.charAt(0).toUpperCase() + camelCaseKey.slice(1);
+  }
+}
+// source/modules/data/transformers/snakeCase.ts
+class SnakeCaseTransformer {
+  convertCase(str) {
+    return str.replace(/(?<lower>[a-z])(?<upper>[A-Z])/gu, "$<lower>_$<upper>").replace(/[-\s]/gu, "_").toLowerCase();
+  }
+}
+export {
+  SnakeCaseTransformer,
+  PascalCaseTransformer,
+  KebabCaseTransformer,
+  CamelCaseTransformer
+};

package/dist/modules/data/transformers/kebabCase.d.ts

@@ -0,0 +1,25 @@
+import type { CaseTransformer } from '../../../modules/data/types/caseTransformer';
+import type { KebabCase } from '../../../modules/data/types/kebabCase';
+/**
+ * Transforms string into `kebab-case` format.
+ * Implements ({@link CaseTransformer}).
+ */
+export declare class KebabCaseTransformer implements CaseTransformer {
+    /**
+     * Transforms a single string from any case to `kebab-case`.
+     *
+     * @template S - The string type to be transformed.
+     *
+     * @param str - The string to transform into `kebab-case`.
+     *
+     * @returns The string transformed into `kebab-case`, with all letters in lower case and words separated by hyphens.
+     *
+     * @example
+     * convertCase('myKeyName'); // "my-key-name"
+     * @example
+     * convertCase('MyKeyName'); // "my-key-name"
+     * @example
+     * convertCase('my_long_key_name'); // "my-long-key-name"
+     */
+    convertCase<S extends string>(str: S): KebabCase<S>;
+}

package/dist/modules/data/transformers/pascalCase.d.ts

@@ -0,0 +1,25 @@
+import type { CaseTransformer } from '../../../modules/data/types/caseTransformer';
+import type { PascalCase } from '../../../modules/data/types/pascalCase';
+/**
+ * Transforms string into `PascalCase` format.
+ * Implements ({@link CaseTransformer}).
+ */
+export declare class PascalCaseTransformer implements CaseTransformer {
+    /**
+     * Transforms a single string from any case to `PascalCase`.
+     *
+     * @template S - The string type to be transformed.
+     *
+     * @param str - The string to transform into `PascalCase`.
+     *
+     * @returns The string transformed into `PascalCase`, with the first letter of each word capitalized.
+     *
+     * @example
+     * convertCase('my_key_name'); // "MyKeyName"
+     * @example
+     * convertCase('my-key-name'); // "MyKeyName"
+     * @example
+     * convertCase('myLongKeyName'); // "MyKeyName"
+     */
+    convertCase<S extends string>(str: S): PascalCase<S>;
+}

package/dist/modules/data/transformers/snakeCase.d.ts

@@ -0,0 +1,25 @@
+import type { CaseTransformer } from '../../../modules/data/types/caseTransformer';
+import type { SnakeCase } from '../../../modules/data/types/snakeCase';
+/**
+ * Transforms string into `snake_case` format.
+ * Implements ({@link CaseTransformer}).
+ */
+export declare class SnakeCaseTransformer implements CaseTransformer {
+    /**
+     * Transforms a single string from any case to `snake_case`.
+     *
+     * @template S - The string type to be transformed.
+     *
+     * @param str - The string to transform into `snake_case`.
+     *
+     * @returns The string transformed into `snake_case`, with underscores between words.
+     *
+     * @example
+     * convertCase('myKeyName'); // "my_key_name"
+     * @example
+     * convertCase('MyKeyName'); // "my_key_name"
+     * @example
+     * convertCase('My-Key-Name'); // "my_key_name"
+     */
+    convertCase<S extends string>(str: S): SnakeCase<S>;
+}

package/dist/modules/data/types/camelCase.d.ts

@@ -0,0 +1 @@
+export type CamelCase<S extends string> = S extends `${infer First}${infer Rest}` ? First extends Uppercase<First> ? `${Lowercase<First>}${CamelCase<Rest>}` : S extends `${infer P1}_${infer P2}${infer P3}` ? `${P1}${Uppercase<P2>}${CamelCase<P3>}` : S extends `${infer P1}-${infer P2}${infer P3}` ? `${P1}${Uppercase<P2>}${CamelCase<P3>}` : S : S;

package/dist/modules/data/types/caseTransformer.d.ts

@@ -0,0 +1,13 @@
+export interface CaseTransformer<TTransform extends string = string> {
+    /**
+     * Transforms a single string from any case to another case.
+     *
+     * @template TTransform - The type of the transformed string.
+     * @template S - The type of the input string.
+     *
+     * @param str - The string to transform.
+     *
+     * @returns The string transformed into the desired case.
+     */
+    convertCase<S extends string>(str: S): TTransform;
+}

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

@@ -0,0 +1,10 @@
+export type { CamelCase } from './camelCase';
+export type { CaseTransformer } from './caseTransformer';
+export type { KebabCase } from './kebabCase';
+export type { PascalCase } from './pascalCase';
+export type { SnakeCase } from './snakeCase';
+export type { TransformKeysCamelCase } from './transformKeysCamelCase';
+export type { TransformKeysKebabCase } from './transformKeysKebabCase';
+export type { TransformKeysPascalCase } from './transformKeysPascalCase';
+export type { TransformKeysSnakeCase } from './transformKeysSnakeCase';
+export type { TransformObjectKeys } from './transformObjectKeys';

package/dist/modules/data/types/kebabCase.d.ts

@@ -0,0 +1 @@
+export type KebabCase<S extends string> = S extends `${infer First}${infer Rest}` ? First extends Uppercase<First> ? `-${Lowercase<First>}${KebabCase<Rest>}` : `${First}${KebabCase<Rest>}` : S;

package/dist/modules/data/types/pascalCase.d.ts

@@ -0,0 +1,2 @@
+import type { CamelCase } from './camelCase';
+export type PascalCase<S extends string> = S extends `${infer First}${infer Rest}` ? `${Uppercase<First>}${CamelCase<Rest>}` : S;

package/dist/modules/data/types/snakeCase.d.ts

@@ -0,0 +1 @@
+export type SnakeCase<S extends string> = S extends `${infer Head}${infer Tail}` ? Head extends Lowercase<Head> ? Tail extends '' ? Head : `${Head}${SnakeCase<Tail>}` : `_${Lowercase<Head>}${SnakeCase<Tail>}` : S;

package/dist/modules/data/types/transformKeysCamelCase.d.ts

@@ -0,0 +1,4 @@
+import type { CamelCase } from './camelCase';
+export type TransformKeysCamelCase<T> = {
+    [K in keyof T as CamelCase<Extract<K, string>>]: T[K];
+};

package/dist/modules/data/types/transformKeysKebabCase.d.ts

@@ -0,0 +1,4 @@
+import type { KebabCase } from './kebabCase';
+export type TransformKeysKebabCase<T> = {
+    [K in keyof T as KebabCase<Extract<K, string>>]: T[K];
+};

package/dist/modules/data/types/transformKeysPascalCase.d.ts

@@ -0,0 +1,4 @@
+import type { PascalCase } from './pascalCase';
+export type TransformKeysPascalCase<T> = {
+    [K in keyof T as PascalCase<Extract<K, string>>]: T[K];
+};

package/dist/modules/data/types/transformKeysSnakeCase.d.ts

@@ -0,0 +1,4 @@
+import type { SnakeCase } from './snakeCase';
+export type TransformKeysSnakeCase<T> = {
+    [K in keyof T as SnakeCase<Extract<K, string>>]: T[K];
+};

package/dist/modules/data/types/transformObjectKeys.d.ts

@@ -0,0 +1,9 @@
+import type { CamelCaseTransformer } from '../../../modules/data/transformers/camelCase';
+import type { KebabCaseTransformer } from '../../../modules/data/transformers/kebabCase';
+import type { PascalCaseTransformer } from '../../../modules/data/transformers/pascalCase';
+import type { SnakeCaseTransformer } from '../../../modules/data/transformers/snakeCase';
+import type { TransformKeysCamelCase } from './transformKeysCamelCase';
+import type { TransformKeysKebabCase } from './transformKeysKebabCase';
+import type { TransformKeysPascalCase } from './transformKeysPascalCase';
+import type { TransformKeysSnakeCase } from './transformKeysSnakeCase';
+export type TransformObjectKeys<T, TTransformer> = TTransformer extends PascalCaseTransformer ? TransformKeysPascalCase<T> : TTransformer extends KebabCaseTransformer ? TransformKeysKebabCase<T> : TTransformer extends SnakeCaseTransformer ? TransformKeysSnakeCase<T> : TTransformer extends CamelCaseTransformer ? TransformKeysCamelCase<T> : Record<string, T[keyof T]>;

package/dist/modules/database/enums/databaseErrorKeys.d.ts

@@ -0,0 +1,28 @@
+export declare const DATABASE_ERROR_KEYS: {
+    readonly MSSQL_CONNECTION_ERROR: "mssql.error.database.connection_error";
+    readonly MSSQL_DISCONNECT_ERROR: "mssql.error.database.disconnect_error";
+    readonly MSSQL_NOT_CONNECTED: "mssql.error.database.not_connected";
+    readonly MSSQL_NO_RESULT: "mssql.error.database.no_result";
+    readonly MSSQL_QUERY_ERROR: "mssql.error.database.query_error";
+    readonly MSSQL_DATABASE_ACCESS_DENIED: "mssql.error.database.access_denied";
+    readonly MSSQL_DATABASE_AUTHORIZATION8FAILED: "mssql.error.database.authorization_failed";
+    readonly MSSQL_DATABASE_SYNTAX_ERROR: "mssql.error.database.syntax_error";
+    readonly MSSQL_DATABASE_COLUMN_NOT_FOUND: "mssql.error.database.column_not_found";
+    readonly MSSQL_TABLE_NOT_FOUND: "mssql.error.database.table_not_found";
+    readonly MSSQL_DATABASE_AMBIGUOUS_COLUMN: "mssql.error.database.ambiguous_column";
+    readonly MSSQL_DATABASE_DUPLICATE_KEY: "mssql.error.database.duplicate_key";
+    readonly MSSQL_DATABASE_FOREIGN_KEY_VIOLATION: "mssql.error.database.foreign_key_violation";
+    readonly MSSQL_DATABASE_UNIQUE_CONSTRAINT_VIOLATION: "mssql.error.database.unique_constraint_violation";
+    readonly MSSQL_DATABASE_DEADLOCK_DETECTED: "mssql.error.database.deadlock_detected";
+    readonly MSSQL_DATABASE_RESOURCE_LOCKED: "mssql.error.database.resource_locked";
+    readonly MSSQL_DATABASE_TRANSACTION_ABORTED: "mssql.error.database.transaction_aborted";
+    readonly MSSQL_DATABASE_INSUFFICIENT_MEMORY: "mssql.error.database.insufficient_memory";
+    readonly MSSQL_DATABASE_INSUFFICIENT_STORAGE: "mssql.error.database.insufficient_storage";
+    readonly MSSQL_DATABASE_QUERY_TIMEOUT: "mssql.error.database.query_timeout";
+    readonly MSSQL_DATABASE_TRANSACTION_LOG_FULL: "mssql.error.database.transaction_log_full";
+    readonly MSSQL_DATABASE_DATA_TOO_LARGE: "mssql.error.database.data_too_large";
+    readonly MSSQL_DATABASE_PERMISSION_DENIED: "mssql.error.database.permission_denied";
+    readonly MSSQL_DATABASE_IDENTITY_INSERT_NOT_ALLOWED: "mssql.error.database.identity_insert_not_allowed";
+    readonly MSSQL_DATABSE_CANNOT_UPDATE_IDENTITY_COLUMN: "mssql.error.database.cannot_update_identity_column";
+    readonly MSSQL_DATABASE_CONVERSION_FAILED: "mssql.error.database.conversion_failed";
+};

package/dist/modules/database/enums/mssqlErrorCode.d.ts

@@ -0,0 +1,25 @@
+export declare const MSSQL_ERROR_CODE: {
+    readonly 0: "mssql.error.database.query_error";
+    readonly 4060: "mssql.error.database.access_denied";
+    readonly 18452: "mssql.error.database.authorization_failed";
+    readonly 18456: "mssql.error.database.authorization_failed";
+    readonly 102: "mssql.error.database.syntax_error";
+    readonly 207: "mssql.error.database.column_not_found";
+    readonly 208: "mssql.error.database.table_not_found";
+    readonly 209: "mssql.error.database.ambiguous_column";
+    readonly 2627: "mssql.error.database.duplicate_key";
+    readonly 547: "mssql.error.database.foreign_key_violation";
+    readonly 2601: "mssql.error.database.unique_constraint_violation";
+    readonly 1205: "mssql.error.database.deadlock_detected";
+    readonly 1222: "mssql.error.database.resource_locked";
+    readonly 3928: "mssql.error.database.transaction_aborted";
+    readonly 701: "mssql.error.database.insufficient_memory";
+    readonly 1105: "mssql.error.database.insufficient_storage";
+    readonly 8645: "mssql.error.database.query_timeout";
+    readonly 9002: "mssql.error.database.transaction_log_full";
+    readonly 8152: "mssql.error.database.data_too_large";
+    readonly 229: "mssql.error.database.permission_denied";
+    readonly 544: "mssql.error.database.identity_insert_not_allowed";
+    readonly 8102: "mssql.error.database.cannot_update_identity_column";
+    readonly 8169: "mssql.error.database.conversion_failed";
+};

package/dist/modules/database/events/index.d.ts

@@ -0,0 +1,2 @@
+export type { MssqlEventMap } from './mssqlEventMap';
+export type { TableEventMap } from './tableEventMap';

package/dist/modules/database/events/mssqlEventMap.d.ts

@@ -0,0 +1,6 @@
+import type { QueryContext } from '../../../modules/database/types/queryContext';
+export interface MssqlEventMap {
+    readonly query: [QueryContext];
+    readonly 'query:response': [unknown[], QueryContext];
+    readonly 'query:error': [Error, QueryContext];
+}

package/dist/modules/database/events/tableEventMap.d.ts

@@ -0,0 +1,7 @@
+import type { QueryContext } from '../../../modules/database/types/queryContext';
+export interface TableEventMap {
+    readonly selected: [unknown, QueryContext];
+    readonly inserted: [unknown, QueryContext];
+    readonly updated: [unknown, QueryContext];
+    readonly deleted: [unknown, QueryContext];
+}

package/dist/modules/database/index.d.ts

@@ -0,0 +1,2 @@
+export { MSSQL } from './mssql';
+export { Table } from './table';