ts-prorm-orm 1.1.0

package/dist/dialects/dialect.js

@@ -0,0 +1,720 @@
+"use strict";
+/**
+ * Base dialect interface for the ORM
+ * Each database dialect implements this interface
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DialectRegistry = exports.BaseDialect = void 0;
+const index_1 = require("../errors/index");
+/**
+ * Abstract base class for database dialects
+ * Provides common functionality for all dialect implementations
+ */
+class BaseDialect {
+    constructor() {
+        this._connection = null;
+        this._connected = false;
+        this.dialectName = 'unknown';
+    }
+    /**
+     * Create a stored procedure (alias for createStoredProcedure)
+     * @param options - Stored procedure options
+     */
+    async createProcedure(options) {
+        return this.createStoredProcedure(options);
+    }
+    /**
+     * Drop a stored procedure (alias for dropStoredProcedure)
+     * @param procedureName - Name of the stored procedure
+     * @param options - Drop options
+     */
+    async dropProcedure(procedureName, options) {
+        return this.dropStoredProcedure(procedureName, options);
+    }
+    /**
+     * Rename a column (default throws error)
+     */
+    async renameColumn(_tableName, _oldColumnName, _newColumnName) {
+        throw new Error(`renameColumn not supported for ${this.dialectName} dialect`);
+    }
+    /**
+     * Add a foreign key (default throws error)
+     */
+    async addForeignKey(_tableName, _columnName, _referencedTableName, _referencedColumnName, _options) {
+        throw new Error(`addForeignKey not supported for ${this.dialectName} dialect`);
+    }
+    /**
+     * Bulk insert records (default implementation)
+     */
+    async bulkInsert(tableName, records, _options) {
+        if (records.length === 0) {
+            return { rows: [], rowCount: 0, fields: [] };
+        }
+        const values = [];
+        const placeholders = [];
+        const columns = Object.keys(records[0]);
+        for (const record of records) {
+            const rowPlaceholders = [];
+            for (let i = 0; i < columns.length; i++) {
+                rowPlaceholders.push(`$${values.length + i + 1}`);
+                values.push(record[columns[i]]);
+            }
+            placeholders.push(`(${rowPlaceholders.join(', ')})`);
+        }
+        const sql = `INSERT INTO ${this.quoteTable(tableName)} (${columns.map((c) => this.escapeId(c)).join(', ')}) VALUES ${placeholders.join(', ')}`;
+        return this.query(sql);
+    }
+    /**
+     * Create a fulltext index (default throws error)
+     */
+    async createFulltextIndex(_tableName, _indexName, _fields, _options) {
+        throw new Error(`createFulltextIndex not supported for ${this.dialectName} dialect`);
+    }
+    /**
+     * Create a spatial index (default throws error)
+     */
+    async createSpatialIndex(_tableName, _indexName, _fields, _options) {
+        throw new Error(`createSpatialIndex not supported for ${this.dialectName} dialect`);
+    }
+    /**
+     * List all schemas in the database
+     */
+    async listSchemas() {
+        return this.showAllSchemas();
+    }
+    /**
+     * Generate SQL for creating a database (default implementation)
+     * @param options - Database creation options
+     */
+    createDatabaseSQL(options) {
+        const parts = [];
+        parts.push(`CREATE DATABASE ${this.quoteIdentifier(options.name)}`);
+        if (options.encoding) {
+            parts.push(`ENCODING = '${options.encoding}'`);
+        }
+        if (options.lcCollate) {
+            parts.push(`LC_COLLATE = '${options.lcCollate}'`);
+        }
+        if (options.lcCtype) {
+            parts.push(`LC_CTYPE = '${options.lcCtype}'`);
+        }
+        if (options.template) {
+            parts.push(`TEMPLATE = ${options.template}`);
+        }
+        if (options.tablespace) {
+            parts.push(`TABLESPACE = ${options.tablespace}`);
+        }
+        if (options.isTemplate !== undefined) {
+            parts.push(options.isTemplate ? 'IS_TEMPLATE = true' : 'IS_TEMPLATE = false');
+        }
+        if (options.collate) {
+            parts.push(`COLLATE = '${options.collate}'`);
+        }
+        return parts.join(' ');
+    }
+    /**
+     * Generate SQL for dropping a database
+     * @param name - Database name to drop
+     */
+    dropDatabaseSQL(name) {
+        return `DROP DATABASE IF EXISTS ${this.quoteIdentifier(name)}`;
+    }
+    /**
+     * Generate SQL for creating a savepoint
+     * @param name - Savepoint name (optional, will be generated if not provided)
+     */
+    createSavepointSQL(name) {
+        const savepointName = name || `sp_${Date.now()}`;
+        return `SAVEPOINT ${savepointName}`;
+    }
+    /**
+     * Generate SQL for releasing a savepoint
+     * @param name - Savepoint name to release
+     */
+    releaseSavepointSQL(name) {
+        return `RELEASE SAVEPOINT ${name}`;
+    }
+    /**
+     * Generate SQL for rolling back to a savepoint
+     * @param name - Savepoint name to rollback to
+     */
+    rollbackToSavepointSQL(name) {
+        return `ROLLBACK TO SAVEPOINT ${name}`;
+    }
+    /**
+     * Create a PostgreSQL extension (only supported in PostgreSQL)
+     * @param extensionName - Name of the extension to create
+     * @param options - Extension options
+     */
+    createExtension(_extensionName, _options) {
+        throw new Error('Extensions are only supported in PostgreSQL');
+    }
+    /**
+     * Drop a PostgreSQL extension (only supported in PostgreSQL)
+     * @param extensionName - Name of the extension to drop
+     * @param options - Drop options
+     */
+    dropExtension(_extensionName, _options) {
+        throw new Error('Extensions are only supported in PostgreSQL');
+    }
+    /**
+     * Get all installed PostgreSQL extensions (only supported in PostgreSQL)
+     * @returns Array of extension information
+     */
+    getExtensions() {
+        throw new Error('Extensions are only supported in PostgreSQL');
+    }
+    /**
+     * Check if a PostgreSQL extension is installed (only supported in PostgreSQL)
+     * @param extensionName - Name of the extension
+     * @returns True if the extension is installed
+     */
+    hasExtension(_extensionName) {
+        throw new Error('Extensions are only supported in PostgreSQL');
+    }
+    /**
+     * Create a PostgreSQL enum type (only supported in PostgreSQL)
+     */
+    createEnumType(_name, _values, _options) {
+        throw new Error('CREATE TYPE ... AS ENUM is only supported in PostgreSQL');
+    }
+    /**
+     * Drop a PostgreSQL type (only supported in PostgreSQL)
+     */
+    dropType(_name, _options) {
+        throw new Error('DROP TYPE is only supported in PostgreSQL');
+    }
+    /**
+     * Create a PostgreSQL domain (only supported in PostgreSQL)
+     */
+    createDomain(_name, _baseType, _options) {
+        throw new Error('CREATE DOMAIN is only supported in PostgreSQL');
+    }
+    /**
+     * Drop a PostgreSQL domain (only supported in PostgreSQL)
+     */
+    dropDomain(_name, _options) {
+        throw new Error('DROP DOMAIN is only supported in PostgreSQL');
+    }
+    // ---------------------------------------------------------------------------
+    // Foreign Data Wrapper stubs – overridden by PostgresDialect
+    // All other dialects throw a DatabaseError.
+    // ---------------------------------------------------------------------------
+    buildCreateServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by this dialect');
+    }
+    buildAlterServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by this dialect');
+    }
+    buildDropServerQuery(_name, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by this dialect');
+    }
+    buildCreateUserMappingQuery(_opts) {
+        throw new Error('Foreign Data Wrappers are not supported by this dialect');
+    }
+    buildAlterUserMappingQuery(_opts) {
+        throw new Error('Foreign Data Wrappers are not supported by this dialect');
+    }
+    buildDropUserMappingQuery(_serverName, _user, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by this dialect');
+    }
+    /**
+     * Create a user mapping (default throws error)
+     */
+    async createUserMapping(_userName, _serverName, _options) {
+        throw new Error(`createUserMapping not supported for ${this.dialectName} dialect`);
+    }
+    /**
+     * Drop a user mapping (default throws error)
+     */
+    async dropUserMapping(_userName, _serverName, _options) {
+        throw new Error(`dropUserMapping not supported for ${this.dialectName} dialect`);
+    }
+    buildCreateForeignTableQuery(_tableName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by this dialect');
+    }
+    buildDropForeignTableQuery(_tableName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by this dialect');
+    }
+    buildImportForeignSchemaQuery(_remoteSchema, _serverName, _opts) {
+        throw new Error('Foreign Data Wrappers are not supported by this dialect');
+    }
+    getServersQuery() {
+        throw new Error('Foreign Data Wrappers are not supported by this dialect');
+    }
+    // ---------------------------------------------------------------------------
+    // User / privilege management stubs – overridden by MySQL and MariaDB dialects.
+    // All other dialects (SQLite, etc.) throw a DatabaseError.
+    // ---------------------------------------------------------------------------
+    buildCreateUserQuery(_username, _options) {
+        throw new index_1.DatabaseError('User management is not supported by this dialect');
+    }
+    buildAlterUserQuery(_username, _options) {
+        throw new index_1.DatabaseError('User management is not supported by this dialect');
+    }
+    buildDropUserQuery(_username, _options) {
+        throw new index_1.DatabaseError('User management is not supported by this dialect');
+    }
+    getUsersQuery() {
+        throw new index_1.DatabaseError('User management is not supported by this dialect');
+    }
+    buildGrantQuery(_options) {
+        throw new index_1.DatabaseError('User management is not supported by this dialect');
+    }
+    buildRevokeQuery(_options) {
+        throw new index_1.DatabaseError('User management is not supported by this dialect');
+    }
+    buildShowGrantsQuery(_username, _host) {
+        throw new index_1.DatabaseError('User management is not supported by this dialect');
+    }
+    buildFlushPrivilegesQuery() {
+        throw new index_1.DatabaseError('User management is not supported by this dialect');
+    }
+    buildCreateRoleQuery(_roleName, _options) {
+        throw new index_1.DatabaseError('User management is not supported by this dialect');
+    }
+    buildDropRoleQuery(_roleName, _options) {
+        throw new index_1.DatabaseError('User management is not supported by this dialect');
+    }
+    buildGrantRoleQuery(_role, _to, _options) {
+        throw new index_1.DatabaseError('User management is not supported by this dialect');
+    }
+    buildRevokeRoleQuery(_role, _from, _options) {
+        throw new index_1.DatabaseError('User management is not supported by this dialect');
+    }
+    getRolesQuery() {
+        throw new index_1.DatabaseError('User management is not supported by this dialect');
+    }
+    /**
+     * Build a JSON/JSONB path query
+     * Default implementation using common JSON extraction syntax
+     *
+     * @param column - The JSON/JSONB column name
+     * @param path - The JSON path to access (e.g., 'key' or 'key.subkey')
+     * @param value - The value to compare against (optional)
+     * @param operator - The comparison operator to use (defaults to =)
+     * @returns SQL fragment and values for the JSON query
+     */
+    buildJsonQuery(column, path, value, operator = '=') {
+        const values = [];
+        const columnRef = this.quoteIdentifier(column);
+        // Convert dot notation path to JSON path
+        const jsonPath = path
+            .split('.')
+            .map((p) => `$.${p}`)
+            .join('');
+        // Build JSON extraction SQL
+        // Using JSON_EXTRACT for compatibility (works with MySQL, SQLite)
+        // For PostgreSQL, dialects should override this method
+        const jsonExtract = `JSON_EXTRACT(${columnRef}, '${jsonPath}')`;
+        if (value !== undefined) {
+            values.push(value);
+            // Use = comparison with the extracted value
+            return { sql: `${jsonExtract} ${operator} ?`, values };
+        }
+        // Just return the JSON extraction without value comparison
+        return { sql: jsonExtract, values };
+    }
+    /**
+     * Format a value for SQL based on its type
+     */
+    formatValue(value) {
+        if (value === null || value === undefined) {
+            return 'NULL';
+        }
+        if (typeof value === 'boolean') {
+            return value ? '1' : '0';
+        }
+        if (typeof value === 'number') {
+            return String(value);
+        }
+        // Handle Date objects or date-like objects
+        if (value instanceof Date || (value && typeof value === 'object' && typeof value.getFullYear === 'function')) {
+            return this.formatDate(new Date(value.getFullYear(), value.getMonth(), value.getDate(), value.getHours(), value.getMinutes(), value.getSeconds(), value.getMilliseconds()));
+        }
+        // Handle date strings
+        if (typeof value === 'string') {
+            const dateStr = value.trim();
+            // Check if it looks like an ISO date string
+            if (/^\d{4}-\d{2}-\d{2}/.test(dateStr) || /^\d{4}-\d{2}-\d{2}T/.test(dateStr)) {
+                const parsedDate = new Date(dateStr);
+                if (!isNaN(parsedDate.getTime())) {
+                    return this.formatDate(parsedDate);
+                }
+            }
+        }
+        if (Buffer.isBuffer(value)) {
+            return `X'${value.toString('hex')}'`;
+        }
+        if (Array.isArray(value) || typeof value === 'object') {
+            return this.escape(JSON.stringify(value));
+        }
+        return this.escape(String(value));
+    }
+    /**
+     * Format a date for SQL
+     */
+    formatDate(date) {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        const hours = String(date.getHours()).padStart(2, '0');
+        const minutes = String(date.getMinutes()).padStart(2, '0');
+        const seconds = String(date.getSeconds()).padStart(2, '0');
+        const milliseconds = String(date.getMilliseconds()).padStart(3, '0');
+        return `'${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${milliseconds}'`;
+    }
+    /**
+     * Replace placeholders in SQL with actual values
+     * Supports both named (:param) and positional (?) placeholders
+     * Properly escapes values to prevent SQL injection
+     */
+    replaceReplacements(sql, replacements) {
+        if (!replacements) {
+            return sql;
+        }
+        // Handle array replacements (positional ?)
+        if (Array.isArray(replacements)) {
+            return this.replacePositionalReplacements(sql, replacements);
+        }
+        // Handle object replacements (named :param)
+        return this.replaceNamedReplacements(sql, replacements);
+    }
+    /**
+     * Replace positional (?) placeholders with escaped values
+     */
+    replacePositionalReplacements(sql, replacements) {
+        let result = sql;
+        let paramIndex = 0;
+        // Use a placeholder to avoid infinite loops with ?
+        const placeholder = '__POS_PLACEHOLDER__';
+        // First, escape the ? to avoid issues with the replacement loop
+        // We'll track positions of ?
+        const matches = [];
+        // Find all ? that are not inside quotes
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        let escaped = false;
+        let i = 0;
+        while (i < result.length) {
+            const char = result[i];
+            if (escaped) {
+                escaped = false;
+                i++;
+                continue;
+            }
+            if (char === '\\') {
+                escaped = true;
+                i++;
+                continue;
+            }
+            if (char === "'" && !inDoubleQuote) {
+                inSingleQuote = !inSingleQuote;
+            }
+            else if (char === '"' && !inSingleQuote) {
+                inDoubleQuote = !inDoubleQuote;
+            }
+            if (!inSingleQuote && !inDoubleQuote && char === '?') {
+                const value = replacements[paramIndex];
+                const escapedValue = this.escapeReplacement(value);
+                matches.push({ index: i, value: escapedValue });
+                paramIndex++;
+            }
+            i++;
+        }
+        // Replace from end to beginning to maintain correct indices
+        for (let i = matches.length - 1; i >= 0; i--) {
+            const match = matches[i];
+            result = result.slice(0, match.index) + match.value + result.slice(match.index + 1);
+        }
+        return result;
+    }
+    /**
+     * Replace named (:param) placeholders with escaped values
+     */
+    replaceNamedReplacements(sql, replacements) {
+        let result = sql;
+        // Find all :param placeholders
+        // Match :param where param is alphanumeric (and possibly with underscores)
+        const namedParamRegex = /:([a-zA-Z_][a-zA-Z0-9_]*)/g;
+        // We need to handle this carefully to avoid replacing inside strings
+        // For simplicity, we'll use a two-pass approach
+        // First pass: identify placeholders not in quotes
+        const matches = [];
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+        const escaped = false;
+        const i = 0;
+        // Make a fresh regex for each call
+        const regex = /:([a-zA-Z_][a-zA-Z0-9_]*)/g;
+        let match;
+        // Reset regex state
+        regex.lastIndex = 0;
+        while ((match = regex.exec(result)) !== null) {
+            // Check if we're inside quotes
+            const beforeMatch = result.slice(0, match.index);
+            const inQuote = false;
+            for (const char of beforeMatch) {
+                if (char === "'" && !inDoubleQuote) {
+                    inSingleQuote = !inSingleQuote;
+                }
+                else if (char === '"' && !inSingleQuote) {
+                    inDoubleQuote = !inDoubleQuote;
+                }
+            }
+            if (!inSingleQuote && !inDoubleQuote) {
+                matches.push({
+                    match: match[0],
+                    param: match[1],
+                    index: match.index,
+                });
+            }
+            // Reset quote state tracking for next iteration
+            inSingleQuote = false;
+            inDoubleQuote = false;
+        }
+        // Replace from end to beginning to maintain correct indices
+        for (let i = matches.length - 1; i >= 0; i--) {
+            const m = matches[i];
+            const value = replacements[m.param];
+            if (value === undefined) {
+                throw new Error(`Replacement parameter :${m.param} is not defined`);
+            }
+            const escapedValue = this.escapeReplacement(value);
+            result = result.slice(0, m.index) + escapedValue + result.slice(m.index + m.match.length);
+        }
+        return result;
+    }
+    /**
+     * Escape a replacement value for safe inclusion in SQL
+     */
+    escapeReplacement(value) {
+        if (value === null || value === undefined) {
+            return 'NULL';
+        }
+        // Handle arrays - convert to (val1, val2, ...) for IN clauses
+        if (Array.isArray(value)) {
+            const escapedValues = value.map((v) => this.escapeReplacement(v));
+            return `(${escapedValues.join(', ')})`;
+        }
+        // Handle boolean
+        if (typeof value === 'boolean') {
+            return value ? '1' : '0';
+        }
+        // Handle numbers
+        if (typeof value === 'number') {
+            return String(value);
+        }
+        // Handle Date
+        if (value instanceof Date) {
+            return this.formatDate(value);
+        }
+        // Handle Buffer
+        if (Buffer.isBuffer(value)) {
+            return `X'${value.toString('hex')}'`;
+        }
+        // Handle objects/arrays as JSON strings
+        if (typeof value === 'object') {
+            return this.escape(JSON.stringify(value));
+        }
+        // Handle strings and other types
+        return this.escape(String(value));
+    }
+    /**
+     * Parse a value from the database
+     */
+    parseValue(value, type) {
+        if (value === null || value === undefined) {
+            return value;
+        }
+        // Handle based on data type
+        const typeObj = type;
+        const typeKey = typeObj?.key || '';
+        switch (typeKey) {
+            case 'BOOLEAN':
+                if (typeof value === 'number') {
+                    return value === 1;
+                }
+                if (typeof value === 'string') {
+                    return value.toLowerCase() === 'true' || value === '1';
+                }
+                return Boolean(value);
+            case 'INTEGER':
+            case 'BIGINT':
+            case 'FLOAT':
+            case 'DOUBLE':
+            case 'DECIMAL':
+                return Number(value);
+            case 'DATE':
+            case 'DATEONLY':
+            case 'TIME':
+                if (typeof value === 'string' || typeof value === 'number') {
+                    return new Date(value);
+                }
+                return value;
+            case 'JSON':
+            case 'JSONB':
+                if (typeof value === 'string') {
+                    try {
+                        return JSON.parse(value);
+                    }
+                    catch {
+                        return value;
+                    }
+                }
+                return value;
+            case 'BLOB':
+                if (typeof value === 'string') {
+                    return Buffer.from(value, 'hex');
+                }
+                return value;
+            default:
+                return value;
+        }
+    }
+    /**
+     * Get the isolation level SQL
+     */
+    getIsolationLevelSql(isolationLevel) {
+        if (!isolationLevel) {
+            return '';
+        }
+        const levels = {
+            'READ UNCOMMITTED': 'READ UNCOMMITTED',
+            'READ COMMITTED': 'READ COMMITTED',
+            'REPEATABLE READ': 'REPEATABLE READ',
+            SERIALIZABLE: 'SERIALIZABLE',
+        };
+        const level = levels[isolationLevel];
+        return level ? `ISOLATION LEVEL ${level}` : '';
+    }
+    /**
+     * Resolve the 'all' include option to actual include configurations
+     */
+    resolveAllInclude(include, parentAlias, depth) {
+        const result = [];
+        const model = include.model;
+        const associations = model?.associations || {};
+        for (const [assocName, association] of Object.entries(associations)) {
+            // If 'all' is a string, only include that specific association
+            if (typeof include.all === 'string' && include.all !== assocName) {
+                continue;
+            }
+            const assocModel = association.target;
+            // Build the include config for this association
+            const assocInclude = {
+                model: assocModel,
+                as: assocName,
+                where: include.where,
+                required: include.required,
+                attributes: include.attributes,
+                order: include.order,
+                limit: include.limit,
+                offset: include.offset,
+                duplicating: include.duplicating,
+            };
+            // Handle nested includes within 'all' - recursively process them
+            if (include.include && include.include.length > 0) {
+                assocInclude.include = this.resolveAllInclude({ all: true, include: include.include }, assocName, depth + 1);
+            }
+            result.push(assocInclude);
+        }
+        return result;
+    }
+    /**
+     * Generate column list with proper aliasing to avoid duplicates
+     */
+    generateSelectColumns(mainTableName, mainTableAlias, attributes, includes) {
+        // If explicit attributes are provided, use those
+        if (attributes) {
+            if (Array.isArray(attributes)) {
+                // Add table alias prefix to avoid duplicates
+                return attributes
+                    .map((a) => `${this.escapeId(mainTableAlias)}.${this.escapeId(a)}`)
+                    .join(', ');
+            }
+            else if (attributes.include) {
+                return attributes.include
+                    .map((a) => `${this.escapeId(mainTableAlias)}.${this.escapeId(a)}`)
+                    .join(', ');
+            }
+            else if (attributes.exclude) {
+                // For exclude, we need to get all columns and exclude specific ones
+                // This is database-specific; for now, return * with EXCEPT
+                return `* EXCEPT (${attributes.exclude.map((a) => this.escapeId(a)).join(', ')})`;
+            }
+        }
+        // Default: select all columns from main table with alias prefix
+        // and all columns from included tables with their aliases
+        const mainColumns = [`${this.escapeId(mainTableAlias)}.*`];
+        // Add columns from included tables to avoid duplicates
+        if (includes && includes.length > 0) {
+            for (const inc of includes) {
+                mainColumns.push(`${this.escapeId(inc.alias)}.*`);
+            }
+        }
+        return mainColumns.join(', ');
+    }
+    /**
+     * Flatten nested includes to handle 'all' option
+     */
+    flattenIncludesWithAll(includes, parentAlias = 'main', depth = 0) {
+        const flattened = [];
+        for (const include of includes) {
+            // Handle 'all' option
+            if (include.all) {
+                const resolved = this.resolveAllInclude(include, parentAlias, depth);
+                for (const res of resolved) {
+                    const nested = this.flattenIncludesWithAll([res], res.as || '', depth + 1);
+                    flattened.push(...nested);
+                }
+                continue;
+            }
+            flattened.push(include);
+            // Recursively process nested includes
+            if (include.include && include.include.length > 0) {
+                const nested = this.flattenIncludesWithAll(include.include, include.as || include.model?.tableName || '', depth + 1);
+                // Replace nested includes with flattened versions
+                include.include = nested;
+            }
+        }
+        return flattened;
+    }
+}
+exports.BaseDialect = BaseDialect;
+/**
+ * Dialect registry for managing available dialects
+ */
+class DialectRegistry {
+    /**
+     * Register a new dialect
+     */
+    static register(name, factory) {
+        this.dialects.set(name.toLowerCase(), factory);
+    }
+    /**
+     * Get a dialect by name
+     */
+    static get(name) {
+        const factory = this.dialects.get(name.toLowerCase());
+        if (!factory) {
+            const available = Array.from(this.dialects.keys()).join(', ');
+            throw new Error(`Dialect "${name}" is not registered. Available dialects: ${available}`);
+        }
+        return factory;
+    }
+    /**
+     * Check if a dialect is registered
+     */
+    static has(name) {
+        return this.dialects.has(name.toLowerCase());
+    }
+    /**
+     * Get all registered dialect names
+     */
+    static getAvailable() {
+        return Array.from(this.dialects.keys());
+    }
+}
+exports.DialectRegistry = DialectRegistry;
+DialectRegistry.dialects = new Map();