accio-orm 0.1.0 → 0.1.1

package/dist/repository/Repository.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Repository = void 0;
+const errors_1 = require("@/errors");
 const MetadataStorage_1 = require("@/metadata/MetadataStorage");
 const QueryBuilder_1 = require("@/query/QueryBuilder");
 const entityMapper_1 = require("../utils/entityMapper");
@@ -25,7 +26,7 @@ class Repository {
     }
     async findById(id) {
         if (!this.metadata.primaryColumn) {
-            throw new Error(`Entity ${this.entityClass.name} has no primary key`);
+            throw new errors_1.QueryError(`Entity ${this.entityClass.name} has no primary key defined`);
         }
         const primaryKey = this.metadata.primaryColumn.columnName;
         const sql = `SELECT * FROM ${this.metadata.tableName} WHERE ${primaryKey} = $1`;
@@ -45,9 +46,9 @@ class Repository {
     }
     save(entity) {
         if (!this.metadata.primaryColumn) {
-            throw new Error(`Entity ${this.entityClass.name} has no primary key`);
+            throw new errors_1.QueryError(`Entity ${this.entityClass.name} has no primary key defined`);
         }
-        const primaryKey = this.metadata.primaryColumn.columnName;
+        const primaryKey = this.metadata.primaryColumn.propertyKey;
         const id = entity[primaryKey];
         if (id !== undefined && id !== null) {
             return this.update(entity);
@@ -62,7 +63,7 @@ class Repository {
     async insert(entity) {
         const columns = this.metadata.columns.filter((col) => !col.isPrimary);
         if (columns.length === 0) {
-            throw new Error(`Entity ${this.entityClass.name} has no columns to insert (only primary key)`);
+            throw new errors_1.QueryError(`Entity ${this.entityClass.name} has no columns to insert (only primary key)`);
         }
         const columnNames = columns.map((col) => col.columnName).join(', ');
         const placeholders = columns.map((_, i) => `$${i + 1}`).join(', ');
@@ -80,11 +81,11 @@ class Repository {
      */
     async update(entity) {
         if (!this.metadata.primaryColumn) {
-            throw new Error(`Entity ${this.entityClass.name} has no primary key`);
+            throw new errors_1.QueryError(`Entity ${this.entityClass.name} has no primary key defined`);
         }
         const columns = this.metadata.columns.filter((col) => !col.isPrimary);
         if (columns.length === 0) {
-            throw new Error(`Entity ${this.entityClass.name} has no columns to update (only primary key)`);
+            throw new errors_1.QueryError(`Entity ${this.entityClass.name} has no columns to update (only primary key)`);
         }
         const primaryKey = this.metadata.primaryColumn.columnName;
         const primaryValue = entity[this.metadata.primaryColumn.propertyKey];
@@ -101,7 +102,7 @@ class Repository {
     `;
         const result = await this.connection.query(sql, [...values, primaryValue]);
         if (result.rows.length === 0) {
-            throw new Error(`Update failed: Entity with ${primaryKey} = ${String(primaryValue)} not found`);
+            throw new errors_1.DatabaseError(`Update failed: Entity with ${primaryKey} = ${String(primaryValue)} not found`, undefined, `No rows affected by UPDATE operation`);
         }
         return (0, entityMapper_1.mapRowToEntity)(result.rows[0], this.entityClass, this.metadata);
     }
@@ -110,12 +111,12 @@ class Repository {
      */
     async delete(entity) {
         if (!this.metadata.primaryColumn) {
-            throw new Error(`Entity ${this.entityClass.name} has no primary key`);
+            throw new errors_1.QueryError(`Entity ${this.entityClass.name} has no primary key defined`);
         }
         const primaryKey = this.metadata.primaryColumn.columnName;
         const primaryValue = entity[this.metadata.primaryColumn.propertyKey];
         if (primaryValue === undefined || primaryValue === null) {
-            throw new Error(`Cannot delete entity: primary key ${primaryKey} is ${primaryValue}`);
+            throw new errors_1.QueryError(`Cannot delete entity: primary key ${primaryKey} is ${primaryValue}`);
         }
         const sql = `DELETE FROM ${this.metadata.tableName} WHERE ${primaryKey} = $1`;
         await this.connection.query(sql, [primaryValue]);
@@ -125,7 +126,7 @@ class Repository {
      */
     async deleteById(id) {
         if (!this.metadata.primaryColumn) {
-            throw new Error(`Entity ${this.entityClass.name} has no primary key`);
+            throw new errors_1.QueryError(`Entity ${this.entityClass.name} has no primary key defined`);
         }
         const primaryKey = this.metadata.primaryColumn.columnName;
         const sql = `DELETE FROM ${this.metadata.tableName} WHERE ${primaryKey} = $1`;
@@ -145,7 +146,7 @@ class Repository {
      */
     async exists(id) {
         if (!this.metadata.primaryColumn) {
-            throw new Error(`Entity ${this.entityClass.name} has no primary key`);
+            throw new errors_1.QueryError(`Entity ${this.entityClass.name} has no primary key defined`);
         }
         const primaryKey = this.metadata.primaryColumn.columnName;
         const sql = `SELECT 1 FROM ${this.metadata.tableName} WHERE ${primaryKey} = $1 LIMIT 1`;

package/dist/types/PostgresTypes.d.ts

@@ -0,0 +1,74 @@
+/**
+ * PostgresSQL column data definitions
+ *
+ * Provides strict type mapping between TypeScript and PostgreSQL types,
+ * ensuring type safety and consistency when defining database columns.
+ *
+ * @example
+ * ```typescript
+ * @Column({ type: PostgresType.INTEGER })
+ * id!: number;
+ *
+ * @Column({ type: PostgresType.TEXT })
+ * name!: string;
+ * ```
+ */
+export declare enum PostgresType {
+    SMALLINT = "SMALLINT",
+    INTEGER = "INTEGER",
+    BIGINT = "BIGINT",
+    DECIMAL = "DECIMAL",
+    NUMERIC = "NUMERIC",
+    REAL = "REAL",
+    DOUBLE_PRECISION = "DOUBLE PRECISION",
+    SMALLSERIAL = "SMALLSERIAL",
+    SERIAL = "SERIAL",
+    BIGSERIAL = "BIGSERIAL",
+    CHAR = "CHAR",
+    VARCHAR = "VARCHAR",
+    TEXT = "TEXT",
+    BOOLEAN = "BOOLEAN",
+    DATE = "DATE",
+    TIME = "TIME",
+    TIME_WITH_TIMEZONE = "TIMETZ",
+    TIMESTAMP = "TIMESTAMP",
+    TIMESTAMP_WITH_TIMEZONE = "TIMESTAMPZ",
+    INTERVAL = "INTERVAL",
+    UUID = "UUID",
+    JSON = "JSON",
+    JSONB = "JSONB",
+    BYTEA = "BYTEA",
+    ARRAY = "ARRAY"
+}
+/**
+ * Mapping from Typescript types to PostgresSQL types
+ *
+ * Used for automatic type inference when no explicit type is specified
+ */
+export declare const TypeScriptToPostgresMap: Record<string, PostgresType>;
+/**
+ * Validates if a string is a valid PostreSQL type
+ *
+ * @param type - The type string to validate
+ * @returns true if the type is a valid PostgreSQL type, false otherwise
+ *
+ * @example
+ * ```typeacript
+ * isValidPostgresType('INTEGER'); // true
+ * isValidPostgresType('INVALID'); // false
+ * ```
+ */
+export declare function isValidPostgresType(type: string): boolean;
+/**
+ * Gets the corresponding PostgresSQL type for a TypeScript type
+ *
+ * @param tsType - The TypeScript type name (e.g. 'number', 'string', 'boolean', 'Date', 'object')
+ * @returns The corresponding PostgresSQL type (e.g. 'INTEGER', 'TEXT', 'BOOLEAN', 'TIMESTAMP', 'JSONB')
+ *
+ * @example
+ * ```typescript
+ * getPostgresTypeForTS('number'); // PostgresType.INTEGER
+ * getPostgresTypeForTS('string'); // PostgresType.TEXT
+ * getPostgresTypeForTS('unknown'); // PostgresType.TEXT
+ */
+export declare function getPostgresTypeForTS(tsType: string): PostgresType;

package/dist/types/PostgresTypes.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeScriptToPostgresMap = exports.PostgresType = void 0;
+exports.isValidPostgresType = isValidPostgresType;
+exports.getPostgresTypeForTS = getPostgresTypeForTS;
+/**
+ * PostgresSQL column data definitions
+ *
+ * Provides strict type mapping between TypeScript and PostgreSQL types,
+ * ensuring type safety and consistency when defining database columns.
+ *
+ * @example
+ * ```typescript
+ * @Column({ type: PostgresType.INTEGER })
+ * id!: number;
+ *
+ * @Column({ type: PostgresType.TEXT })
+ * name!: string;
+ * ```
+ */
+var PostgresType;
+(function (PostgresType) {
+    // Numeric
+    PostgresType["SMALLINT"] = "SMALLINT";
+    PostgresType["INTEGER"] = "INTEGER";
+    PostgresType["BIGINT"] = "BIGINT";
+    PostgresType["DECIMAL"] = "DECIMAL";
+    PostgresType["NUMERIC"] = "NUMERIC";
+    PostgresType["REAL"] = "REAL";
+    PostgresType["DOUBLE_PRECISION"] = "DOUBLE PRECISION";
+    PostgresType["SMALLSERIAL"] = "SMALLSERIAL";
+    PostgresType["SERIAL"] = "SERIAL";
+    PostgresType["BIGSERIAL"] = "BIGSERIAL";
+    // Character
+    PostgresType["CHAR"] = "CHAR";
+    PostgresType["VARCHAR"] = "VARCHAR";
+    PostgresType["TEXT"] = "TEXT";
+    // Boolean
+    PostgresType["BOOLEAN"] = "BOOLEAN";
+    // Date / Time
+    PostgresType["DATE"] = "DATE";
+    PostgresType["TIME"] = "TIME";
+    PostgresType["TIME_WITH_TIMEZONE"] = "TIMETZ";
+    PostgresType["TIMESTAMP"] = "TIMESTAMP";
+    PostgresType["TIMESTAMP_WITH_TIMEZONE"] = "TIMESTAMPZ";
+    PostgresType["INTERVAL"] = "INTERVAL";
+    // UUID
+    PostgresType["UUID"] = "UUID";
+    // JSON
+    PostgresType["JSON"] = "JSON";
+    PostgresType["JSONB"] = "JSONB";
+    // Binary
+    PostgresType["BYTEA"] = "BYTEA";
+    // Arrays (generic)
+    PostgresType["ARRAY"] = "ARRAY";
+})(PostgresType || (exports.PostgresType = PostgresType = {}));
+/**
+ * Mapping from Typescript types to PostgresSQL types
+ *
+ * Used for automatic type inference when no explicit type is specified
+ */
+exports.TypeScriptToPostgresMap = {
+    number: PostgresType.INTEGER,
+    string: PostgresType.TEXT,
+    boolean: PostgresType.BOOLEAN,
+    Date: PostgresType.TIMESTAMP,
+    object: PostgresType.JSONB
+};
+/**
+ * Validates if a string is a valid PostreSQL type
+ *
+ * @param type - The type string to validate
+ * @returns true if the type is a valid PostgreSQL type, false otherwise
+ *
+ * @example
+ * ```typeacript
+ * isValidPostgresType('INTEGER'); // true
+ * isValidPostgresType('INVALID'); // false
+ * ```
+ */
+function isValidPostgresType(type) {
+    return Object.values(PostgresType).includes(type);
+}
+/**
+ * Gets the corresponding PostgresSQL type for a TypeScript type
+ *
+ * @param tsType - The TypeScript type name (e.g. 'number', 'string', 'boolean', 'Date', 'object')
+ * @returns The corresponding PostgresSQL type (e.g. 'INTEGER', 'TEXT', 'BOOLEAN', 'TIMESTAMP', 'JSONB')
+ *
+ * @example
+ * ```typescript
+ * getPostgresTypeForTS('number'); // PostgresType.INTEGER
+ * getPostgresTypeForTS('string'); // PostgresType.TEXT
+ * getPostgresTypeForTS('unknown'); // PostgresType.TEXT
+ */
+function getPostgresTypeForTS(tsType) {
+    return exports.TypeScriptToPostgresMap[tsType] ?? PostgresType.TEXT;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * TypeScript types for the Accio ORM
+ *
+ * Provides strict type mapping between TypeScript and PostgreSQL types,
+ */
+export { getPostgresTypeForTS, isValidPostgresType, PostgresType } from './PostgresTypes';

package/dist/types/index.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * TypeScript types for the Accio ORM
+ *
+ * Provides strict type mapping between TypeScript and PostgreSQL types,
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresType = exports.isValidPostgresType = exports.getPostgresTypeForTS = void 0;
+var PostgresTypes_1 = require("./PostgresTypes");
+Object.defineProperty(exports, "getPostgresTypeForTS", { enumerable: true, get: function () { return PostgresTypes_1.getPostgresTypeForTS; } });
+Object.defineProperty(exports, "isValidPostgresType", { enumerable: true, get: function () { return PostgresTypes_1.isValidPostgresType; } });
+Object.defineProperty(exports, "PostgresType", { enumerable: true, get: function () { return PostgresTypes_1.PostgresType; } });

package/dist/validation/ConnectionValidation.d.ts

@@ -0,0 +1,27 @@
+import type { ConnectionConfig } from '@/connection/types';
+/**
+ * Validates connection configuration
+ *
+ * Ensures all required connection parameters are provided and valid
+ * beforre attempting to establish a database connection.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   ConnectioValidator.validate(config);
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     console.error(`Invalid config: ${error.field}`);
+ *   }
+ * }
+ * ```
+ */
+export declare class ConnectionValidator {
+    /**
+     * Validate connection configuration
+     *
+     * @param config - The connection configuration to validate
+     * @throws {ValidationError} if any configuration parameter is invalid
+     */
+    static validate(config: ConnectionConfig): void;
+}

package/dist/validation/ConnectionValidation.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionValidator = void 0;
+const errors_1 = require("@/errors");
+/**
+ * Validates connection configuration
+ *
+ * Ensures all required connection parameters are provided and valid
+ * beforre attempting to establish a database connection.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   ConnectioValidator.validate(config);
+ * } catch (error) {
+ *   if (error instanceof ValidationError) {
+ *     console.error(`Invalid config: ${error.field}`);
+ *   }
+ * }
+ * ```
+ */
+class ConnectionValidator {
+    /**
+     * Validate connection configuration
+     *
+     * @param config - The connection configuration to validate
+     * @throws {ValidationError} if any configuration parameter is invalid
+     */
+    static validate(config) {
+        if (!config.host ||
+            typeof config.host !== 'string' ||
+            config.host.trim() === '') {
+            throw new errors_1.ValidationError('Connection host must be a non-empty string', 'host', config.host);
+        }
+        if (!config.database ||
+            typeof config.database !== 'string' ||
+            config.database.trim() === '') {
+            throw new errors_1.ValidationError('Database name must be a non-empty string', 'database', config.database);
+        }
+        if (!config.user ||
+            typeof config.user !== 'string' ||
+            config.user.trim() === '') {
+            throw new errors_1.ValidationError('Database user must be a non-empty string', 'user', config.user);
+        }
+        if (!config.password || typeof config.password !== 'string') {
+            throw new errors_1.ValidationError('Database password must be a non-empty string', 'password', '[REDACTED]');
+        }
+        if (config.port !== undefined) {
+            if (typeof config.port !== 'number' || !Number.isInteger(config.port)) {
+                throw new errors_1.ValidationError('Port must be an integer', 'port', config.port);
+            }
+            if (config.port < 1 || config.port > 65535) {
+                throw new errors_1.ValidationError('Port must be between 1 and 65535', 'port', config.port);
+            }
+        }
+    }
+}
+exports.ConnectionValidator = ConnectionValidator;

package/dist/validation/IdentifierValidator.d.ts

@@ -0,0 +1,101 @@
+import type { EntityMetadata } from '@/metadata/types';
+/**
+ * Validate SQL identifiers (table/column names) against metadata
+ *
+ * **CRITICAL FOR SECURITY**: Prevents SQL injection through identifier manipulation.
+ * All table and column names must be validated against entity metadata before
+ * being used in SQL queries
+ *
+ * @example
+ * ```typescript
+ * // Validate that a column exists in metadata (prevents injection)
+ * IdentifierValidator.validateColumnName(
+ *   userInput,
+ *   metadata,
+ *  'ORDER BY'
+ * );
+ * ```
+ */
+export declare class identifierValidator {
+    /**
+     * PostgresSQL identifier rules
+     * - Max 63 characters
+     * - Must start with letter or underscore
+     * - Can contain letters, numbers, and underscores
+     */
+    private static readonly IDENTIFIER_REGEX;
+    /**
+     * Validate that a string is a safe SQL identifier
+     *
+     * @param identifier = The identifier to validate
+     * @returns true if valid, false otherwise
+     *
+     * @example
+     * ```typescript
+     * IdentifierValidator.isValidIdentifier('user_name'); // true
+     * IdentifierValidator.isValidIdentifier('1user'); // false
+     * ```
+     */
+    static isValidIdentifier(identifier: string): boolean;
+    /**
+     * Validate identifier format or throw
+     *
+     * @param identifier - The identifier to validate
+     * @param context - Context description for error message
+     * @throws {ValidationError} If identifier format is invalid
+     *
+     * @example
+     * ```typescript
+     * IdentifierValidator.validateIdentifier('users', 'table name');
+     * ```
+     */
+    static validateIdentifier(identifier: string, context: string): void;
+    /**
+     * Validate identifier format or throw
+     *
+     * @param propertyKey - The property ket to validate
+     * @param metadata - Entity metadata to check against
+     * @param operation - Operation context for error message
+     * @throws {ValidationError} If property doesn't exist
+     *
+     * @example
+     * ```typescript
+     * IdentifierValidator.validatePropertyExists(
+     *   'age',
+     *   metadata,
+     *   'WHERE clause'
+     * );
+     * ```
+     */
+    static validatePropertyExists(propertyKey: string, metadata: EntityMetadata, operation: string): void;
+    /**
+     *
+     * @param columnName - The column name to validate
+     * @param metadata - Entity metadata to check against
+     * @param operation - Operation context for error message
+     * @throws {ValidationError} if column doesn't exist in metadata
+     *
+     * @example
+     * ```typescript
+     * // Prevent injection in ORDER BY clause
+     * IdentifierValidator.validateColumnName(
+     *   orderByColumn,
+     *   metadata,
+     *  'ORDER BY'
+     * );
+     * ```
+     */
+    static validateColumnName(columnName: string, metadata: EntityMetadata, operation: string): void;
+    /**
+     * Validate table name format
+     *
+     * @param tableName - The table name to validate
+     * @throws {ValidationError} If table name format is invalid
+     *
+     * @example
+     * ```typescript
+     * IdentifierValidator.validateTableName('users');
+     * ```
+     */
+    static validateTableName(tableName: string): void;
+}

package/dist/validation/IdentifierValidator.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identifierValidator = void 0;
+const errors_1 = require("@/errors");
+/**
+ * Validate SQL identifiers (table/column names) against metadata
+ *
+ * **CRITICAL FOR SECURITY**: Prevents SQL injection through identifier manipulation.
+ * All table and column names must be validated against entity metadata before
+ * being used in SQL queries
+ *
+ * @example
+ * ```typescript
+ * // Validate that a column exists in metadata (prevents injection)
+ * IdentifierValidator.validateColumnName(
+ *   userInput,
+ *   metadata,
+ *  'ORDER BY'
+ * );
+ * ```
+ */
+class identifierValidator {
+    /**
+     * Validate that a string is a safe SQL identifier
+     *
+     * @param identifier = The identifier to validate
+     * @returns true if valid, false otherwise
+     *
+     * @example
+     * ```typescript
+     * IdentifierValidator.isValidIdentifier('user_name'); // true
+     * IdentifierValidator.isValidIdentifier('1user'); // false
+     * ```
+     */
+    static isValidIdentifier(identifier) {
+        return this.IDENTIFIER_REGEX.test(identifier);
+    }
+    /**
+     * Validate identifier format or throw
+     *
+     * @param identifier - The identifier to validate
+     * @param context - Context description for error message
+     * @throws {ValidationError} If identifier format is invalid
+     *
+     * @example
+     * ```typescript
+     * IdentifierValidator.validateIdentifier('users', 'table name');
+     * ```
+     */
+    static validateIdentifier(identifier, context) {
+        if (!this.isValidIdentifier(identifier)) {
+            throw new errors_1.ValidationError(`Invalid ${context} identifier: "${identifier}". ` +
+                'Identifiers must start with a letter or underscore, contain only ' +
+                'alphanumeric characters and underscores, and be max 63 characters', context, identifier);
+        }
+    }
+    /**
+     * Validate identifier format or throw
+     *
+     * @param propertyKey - The property ket to validate
+     * @param metadata - Entity metadata to check against
+     * @param operation - Operation context for error message
+     * @throws {ValidationError} If property doesn't exist
+     *
+     * @example
+     * ```typescript
+     * IdentifierValidator.validatePropertyExists(
+     *   'age',
+     *   metadata,
+     *   'WHERE clause'
+     * );
+     * ```
+     */
+    static validatePropertyExists(propertyKey, metadata, operation) {
+        const exists = metadata.columns.some((col) => col.propertyKey === propertyKey);
+        if (!exists) {
+            throw new errors_1.ValidationError(`Property '${propertyKey}' does not exist on entity ${metadata.tableName} for ${operation}. ` +
+                `Available properties: ${metadata.columns.map((c) => c.propertyKey).join(', ')}`, 'propertyKey', propertyKey, { entityName: metadata.tableName, operation });
+        }
+    }
+    /**
+     *
+     * @param columnName - The column name to validate
+     * @param metadata - Entity metadata to check against
+     * @param operation - Operation context for error message
+     * @throws {ValidationError} if column doesn't exist in metadata
+     *
+     * @example
+     * ```typescript
+     * // Prevent injection in ORDER BY clause
+     * IdentifierValidator.validateColumnName(
+     *   orderByColumn,
+     *   metadata,
+     *  'ORDER BY'
+     * );
+     * ```
+     */
+    static validateColumnName(columnName, metadata, operation) {
+        const exists = metadata.columns.some((col) => col.columnName === columnName);
+        if (!exists) {
+            throw new errors_1.ValidationError(`Column '${columnName}' does not exist in table ${metadata.tableName} for ${operation}. ` +
+                `Available columns: ${metadata.columns.map((c) => c.columnName).join(', ')}`, 'columnName', columnName, { entityName: metadata.tableName, operation });
+        }
+    }
+    /**
+     * Validate table name format
+     *
+     * @param tableName - The table name to validate
+     * @throws {ValidationError} If table name format is invalid
+     *
+     * @example
+     * ```typescript
+     * IdentifierValidator.validateTableName('users');
+     * ```
+     */
+    static validateTableName(tableName) {
+        this.validateIdentifier(tableName, 'table name');
+    }
+}
+exports.identifierValidator = identifierValidator;
+/**
+ * PostgresSQL identifier rules
+ * - Max 63 characters
+ * - Must start with letter or underscore
+ * - Can contain letters, numbers, and underscores
+ */
+identifierValidator.IDENTIFIER_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]{0,62}$/;

package/dist/validation/QueryValidator.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Validate query paramters and options
+ *
+ * Ensures query parameters like LIMIT, OFFSET, and ORDER BY direction
+ * are valid before building SQL queries.
+ *
+ * @example
+ * ```typescript
+ * QueryValidator.validateLimit(10); // OK
+ * QueryValidator.validateLimit(-5); // Throws ValidationError
+ * ```
+ */
+export declare class QueryValidator {
+    /**
+     * Maximum safe LIMIT value to prevent memory issues
+     */
+    private static readonly MAX_LIMIT;
+    /**
+     * Validate LIMIT value
+     *
+     * @param value - The limit value to validate
+     * @throws {ValidationError} If limit is invalid
+     *
+     * @example
+     * ```typescript
+     * QueryValidator.validateLimit(100); // OK
+     * QueryValidator.validateLimit(-1); // Throws
+     * QueryValidator.validateLimit(20000); // Throws (exceeds max)
+     * ```
+     */
+    static validateLimit(value: number): void;
+    /**
+     * Validate OFFSET value
+     *
+     * @param value - The offset value to validate
+     * @throws {ValidationError} If offset is invalid
+     *
+     * @example
+     * ```typescript
+     * QueryValidator.validateOffset(0); // OK
+     * QueryValidator.validateOffset(100); // OK
+     * QueryValidator.validateOffset(-1); // Throws
+     * QueryValidator.validateOffset(3.14); // Throws (not integer)
+     * ```
+     */
+    static validateOffset(value: number): void;
+    /**
+     * Validate ORDER BY direction
+     *
+     * @param direction - The order direction to validate
+     * @throws {ValidationError} If direction is not 'ASC' or 'DESC'
+     *
+     * @example
+     * ```typescript
+     * QueryValidator.validateOrderDirection('ASC'); // OK
+     * QueryValidator.validateOrderDirection('DESC'); // OK
+     * QueryValidator.validateOrderDirection('RANDOM'); // Throws
+     * ```
+     */
+    static validateOrderDirection(direction: string): void;
+}