@algochad/prisma-core/dist/collections/prisma/database-dialect.js

A comprehensive NestJS library that provides EF-Core-like operations using Prisma and GraphQL. Features LINQ-style query builders, advanced data manipulation, GraphQL integration with genql, and a unified API for both Prisma and GraphQL operations. Includ

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.DatabaseDialectDetector = void 0;
class DatabaseDialectDetector {
    static configs = new Map([
        [
            'postgresql',
            {
                dialect: 'postgresql',
                supportsJsonOperations: true,
                supportsArrayOperations: true,
                supportsCaseInsensitive: true,
                supportsFullTextSearch: true,
                defaultStringComparison: 'sensitive',
            },
        ],
        [
            'sqlite',
            {
                dialect: 'sqlite',
                supportsJsonOperations: true,
                supportsArrayOperations: false,
                supportsCaseInsensitive: true,
                supportsFullTextSearch: true,
                defaultStringComparison: 'sensitive',
            },
        ],
        [
            'mysql',
            {
                dialect: 'mysql',
                supportsJsonOperations: true,
                supportsArrayOperations: false,
                supportsCaseInsensitive: true,
                supportsFullTextSearch: true,
                defaultStringComparison: 'insensitive',
            },
        ],
    ]);
    static detectDialect(prismaClient, connectionString) {
        if (prismaClient) {
            try {
                const engineConfig = prismaClient._engine?.config;
                const datasource = engineConfig?.datasources?.[0];
                if (datasource?.provider) {
                    const provider = datasource.provider.toLowerCase();
                    if (provider.includes('postgresql') ||
                        provider.includes('postgres')) {
                        return 'postgresql';
                    }
                    if (provider.includes('sqlite')) {
                        return 'sqlite';
                    }
                    if (provider.includes('mysql')) {
                        return 'mysql';
                    }
                }
            }
            catch (error) {
                console.warn('Could not detect dialect from Prisma client:', error);
            }
        }
        if (connectionString) {
            const lower = connectionString.toLowerCase();
            if (lower.startsWith('postgresql://') ||
                lower.startsWith('postgres://')) {
                return 'postgresql';
            }
            if (lower.startsWith('file:') || lower.includes('sqlite')) {
                return 'sqlite';
            }
            if (lower.startsWith('mysql://')) {
                return 'mysql';
            }
        }
        const databaseUrl = process.env.DATABASE_URL;
        if (databaseUrl) {
            return this.detectDialect(undefined, databaseUrl);
        }
        console.warn('Could not detect database dialect, defaulting to PostgreSQL');
        return 'postgresql';
    }
    static getConfig(dialect) {
        return this.configs.get(dialect) || this.configs.get('postgresql');
    }
    static supportsFeature(dialect, feature) {
        const config = this.getConfig(dialect);
        return Boolean(config[feature]);
    }
    static getQueryHints(dialect) {
        switch (dialect) {
            case 'postgresql':
                return {
                    useIndexHints: false,
                    preferSubqueries: true,
                    optimizeJsonQueries: true,
                };
            case 'sqlite':
                return {
                    useIndexHints: true,
                    preferSubqueries: false,
                    optimizeJsonQueries: false,
                };
            case 'mysql':
                return {
                    useIndexHints: true,
                    preferSubqueries: false,
                    optimizeJsonQueries: true,
                };
            default:
                return {
                    useIndexHints: false,
                    preferSubqueries: true,
                    optimizeJsonQueries: false,
                };
        }
    }
    static adjustQueryForDialect(query, dialect) {
        const config = this.getConfig(dialect);
        const adjustedQuery = { ...query };
        if (adjustedQuery.where) {
            adjustedQuery.where = this.adjustWhereClause(adjustedQuery.where, config);
        }
        if (adjustedQuery.orderBy) {
            adjustedQuery.orderBy = this.adjustOrderByClause(adjustedQuery.orderBy, config);
        }
        return adjustedQuery;
    }
    static adjustWhereClause(where, config) {
        if (!where || typeof where !== 'object') {
            return where;
        }
        const adjusted = { ...where };
        Object.keys(adjusted).forEach((key) => {
            const value = adjusted[key];
            if (key === 'AND' || key === 'OR') {
                if (Array.isArray(value)) {
                    adjusted[key] = value.map((item) => this.adjustWhereClause(item, config));
                }
            }
            else if (typeof value === 'object' && value !== null) {
                adjusted[key] = this.adjustFieldCondition(value, config);
            }
        });
        return adjusted;
    }
    static adjustFieldCondition(condition, config) {
        if (!condition || typeof condition !== 'object') {
            return condition;
        }
        const adjusted = { ...condition };
        if (adjusted.contains !== undefined ||
            adjusted.startsWith !== undefined ||
            adjusted.endsWith !== undefined) {
            if (!adjusted.mode &&
                config.defaultStringComparison === 'insensitive') {
                adjusted.mode = 'insensitive';
            }
        }
        if (adjusted.has !== undefined && !config.supportsArrayOperations) {
            console.warn('Array operations not fully supported on this dialect, query may not work as expected');
        }
        return adjusted;
    }
    static adjustOrderByClause(orderBy, config) {
        return orderBy;
    }
}
exports.DatabaseDialectDetector = DatabaseDialectDetector;
//# sourceMappingURL=database-dialect.js.map