noormme 1.0.0

package/dist/esm/parser/set-operation-parser.js

@@ -0,0 +1,14 @@
+/// <reference types="./set-operation-parser.d.ts" />
+import { createExpressionBuilder, } from '../expression/expression-builder.js';
+import { SetOperationNode, } from '../operation-node/set-operation-node.js';
+import { isFunction, isReadonlyArray } from '../util/object-utils.js';
+import { parseExpression } from './expression-parser.js';
+export function parseSetOperations(operator, expression, all) {
+    if (isFunction(expression)) {
+        expression = expression(createExpressionBuilder());
+    }
+    if (!isReadonlyArray(expression)) {
+        expression = [expression];
+    }
+    return expression.map((expr) => SetOperationNode.create(operator, parseExpression(expr), all));
+}

package/dist/esm/parser/table-parser.d.ts

@@ -0,0 +1,24 @@
+import { AliasNode } from '../operation-node/alias-node.js';
+import { TableNode } from '../operation-node/table-node.js';
+import { AliasedExpressionOrFactory } from './expression-parser.js';
+import { OperationNode } from '../operation-node/operation-node.js';
+import { AliasedExpression } from '../expression/expression.js';
+import { DrainOuterGeneric } from '../util/type-utils.js';
+import { AliasedDynamicTableBuilder } from '../dynamic/dynamic-table-builder.js';
+export type TableExpression<DB, TB extends keyof DB> = AnyAliasedTable<DB> | AnyTable<DB> | AliasedExpressionOrFactory<DB, TB> | AliasedDynamicTableBuilder<any, any>;
+export type TableExpressionOrList<DB, TB extends keyof DB> = TableExpression<DB, TB> | ReadonlyArray<TableExpression<DB, TB>>;
+export type SimpleTableReference<DB> = AnyAliasedTable<DB> | AnyTable<DB>;
+export type AnyAliasedTable<DB> = `${AnyTable<DB>} as ${string}`;
+export type AnyTable<DB> = keyof DB & string;
+export type From<DB, TE> = DrainOuterGeneric<{
+    [C in keyof DB | ExtractAliasFromTableExpression<DB, TE>]: C extends ExtractAliasFromTableExpression<DB, TE> ? ExtractRowTypeFromTableExpression<DB, TE, C> : C extends keyof DB ? DB[C] : never;
+}>;
+export type FromTables<DB, TB extends keyof DB, TE> = DrainOuterGeneric<TB | ExtractAliasFromTableExpression<DB, TE>>;
+export type ExtractTableAlias<DB, TE> = TE extends `${string} as ${infer TA}` ? TA extends keyof DB ? TA : never : TE extends keyof DB ? TE : never;
+type ExtractAliasFromTableExpression<DB, TE> = TE extends string ? TE extends `${string} as ${infer TA}` ? TA : TE extends keyof DB ? TE : never : TE extends AliasedExpression<any, infer QA> ? QA : TE extends (qb: any) => AliasedExpression<any, infer QA> ? QA : TE extends AliasedDynamicTableBuilder<any, infer DA> ? DA : never;
+type ExtractRowTypeFromTableExpression<DB, TE, A extends keyof any> = TE extends `${infer T} as ${infer TA}` ? TA extends A ? T extends keyof DB ? DB[T] : never : never : TE extends A ? TE extends keyof DB ? DB[TE] : never : TE extends AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends (qb: any) => AliasedExpression<infer O, infer QA> ? QA extends A ? O : never : TE extends AliasedDynamicTableBuilder<infer T, infer DA> ? DA extends A ? T extends keyof DB ? DB[T] : never : never : never;
+export declare function parseTableExpressionOrList(table: TableExpressionOrList<any, any>): OperationNode[];
+export declare function parseTableExpression(table: TableExpression<any, any>): OperationNode;
+export declare function parseAliasedTable(from: string): TableNode | AliasNode;
+export declare function parseTable(from: string): TableNode;
+export {};

package/dist/esm/parser/table-parser.js

@@ -0,0 +1,49 @@
+/// <reference types="./table-parser.d.ts" />
+import { isReadonlyArray, isString } from '../util/object-utils.js';
+import { AliasNode } from '../operation-node/alias-node.js';
+import { TableNode } from '../operation-node/table-node.js';
+import { parseAliasedExpression, } from './expression-parser.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { isAliasedDynamicTableBuilder, } from '../dynamic/dynamic-table-builder.js';
+export function parseTableExpressionOrList(table) {
+    if (isReadonlyArray(table)) {
+        return table.map((it) => parseTableExpression(it));
+    }
+    else {
+        return [parseTableExpression(table)];
+    }
+}
+export function parseTableExpression(table) {
+    if (isString(table)) {
+        return parseAliasedTable(table);
+    }
+    else if (isAliasedDynamicTableBuilder(table)) {
+        return table.toOperationNode();
+    }
+    else {
+        return parseAliasedExpression(table);
+    }
+}
+export function parseAliasedTable(from) {
+    const ALIAS_SEPARATOR = ' as ';
+    if (from.includes(ALIAS_SEPARATOR)) {
+        const [table, alias] = from.split(ALIAS_SEPARATOR).map(trim);
+        return AliasNode.create(parseTable(table), IdentifierNode.create(alias));
+    }
+    else {
+        return parseTable(from);
+    }
+}
+export function parseTable(from) {
+    const SCHEMA_SEPARATOR = '.';
+    if (from.includes(SCHEMA_SEPARATOR)) {
+        const [schema, table] = from.split(SCHEMA_SEPARATOR).map(trim);
+        return TableNode.createWithSchema(schema, table);
+    }
+    else {
+        return TableNode.create(from);
+    }
+}
+function trim(str) {
+    return str.trim();
+}

package/dist/esm/parser/top-parser.d.ts

@@ -0,0 +1,2 @@
+import { TopModifier, TopNode } from '../operation-node/top-node.js';
+export declare function parseTop(expression: number | bigint, modifiers?: TopModifier): TopNode;

package/dist/esm/parser/top-parser.js

@@ -0,0 +1,17 @@
+/// <reference types="./top-parser.d.ts" />
+import { TopNode } from '../operation-node/top-node.js';
+import { isBigInt, isNumber, isUndefined } from '../util/object-utils.js';
+export function parseTop(expression, modifiers) {
+    if (!isNumber(expression) && !isBigInt(expression)) {
+        throw new Error(`Invalid top expression: ${expression}`);
+    }
+    if (!isUndefined(modifiers) && !isTopModifiers(modifiers)) {
+        throw new Error(`Invalid top modifiers: ${modifiers}`);
+    }
+    return TopNode.create(expression, modifiers);
+}
+function isTopModifiers(modifiers) {
+    return (modifiers === 'percent' ||
+        modifiers === 'with ties' ||
+        modifiers === 'percent with ties');
+}

package/dist/esm/parser/tuple-parser.d.ts

@@ -0,0 +1,47 @@
+import { DrainOuterGeneric } from '../util/type-utils.js';
+import { ExtractTypeFromReferenceExpression } from './reference-parser.js';
+import { ExtractTypeFromValueExpression } from './value-parser.js';
+export type RefTuple2<DB, TB extends keyof DB, R1, R2> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>
+]>;
+export type RefTuple3<DB, TB extends keyof DB, R1, R2, R3> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>,
+    ExtractTypeFromReferenceExpression<DB, TB, R3>
+]>;
+export type RefTuple4<DB, TB extends keyof DB, R1, R2, R3, R4> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>,
+    ExtractTypeFromReferenceExpression<DB, TB, R3>,
+    ExtractTypeFromReferenceExpression<DB, TB, R4>
+]>;
+export type RefTuple5<DB, TB extends keyof DB, R1, R2, R3, R4, R5> = DrainOuterGeneric<[
+    ExtractTypeFromReferenceExpression<DB, TB, R1>,
+    ExtractTypeFromReferenceExpression<DB, TB, R2>,
+    ExtractTypeFromReferenceExpression<DB, TB, R3>,
+    ExtractTypeFromReferenceExpression<DB, TB, R4>,
+    ExtractTypeFromReferenceExpression<DB, TB, R5>
+]>;
+export type ValTuple2<V1, V2> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>
+]>;
+export type ValTuple3<V1, V2, V3> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>,
+    ExtractTypeFromValueExpression<V3>
+]>;
+export type ValTuple4<V1, V2, V3, V4> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>,
+    ExtractTypeFromValueExpression<V3>,
+    ExtractTypeFromValueExpression<V4>
+]>;
+export type ValTuple5<V1, V2, V3, V4, V5> = DrainOuterGeneric<[
+    ExtractTypeFromValueExpression<V1>,
+    ExtractTypeFromValueExpression<V2>,
+    ExtractTypeFromValueExpression<V3>,
+    ExtractTypeFromValueExpression<V4>,
+    ExtractTypeFromValueExpression<V5>
+]>;

package/dist/esm/parser/tuple-parser.js

@@ -0,0 +1,2 @@
+/// <reference types="./tuple-parser.d.ts" />
+export {};

package/dist/esm/parser/unary-operation-parser.d.ts

@@ -0,0 +1,8 @@
+import { UnaryOperator } from '../operation-node/operator-node.js';
+import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
+import { ExpressionOrFactory } from './expression-parser.js';
+import { ReferenceExpression } from './reference-parser.js';
+export type ExistsExpression<DB, TB extends keyof DB> = ExpressionOrFactory<DB, TB, any>;
+export declare function parseExists(operand: ExistsExpression<any, any>): UnaryOperationNode;
+export declare function parseNotExists(operand: ExistsExpression<any, any>): UnaryOperationNode;
+export declare function parseUnaryOperation(operator: UnaryOperator, operand: ReferenceExpression<any, any>): UnaryOperationNode;

package/dist/esm/parser/unary-operation-parser.js

@@ -0,0 +1,13 @@
+/// <reference types="./unary-operation-parser.d.ts" />
+import { OperatorNode } from '../operation-node/operator-node.js';
+import { UnaryOperationNode } from '../operation-node/unary-operation-node.js';
+import { parseReferenceExpression, } from './reference-parser.js';
+export function parseExists(operand) {
+    return parseUnaryOperation('exists', operand);
+}
+export function parseNotExists(operand) {
+    return parseUnaryOperation('not exists', operand);
+}
+export function parseUnaryOperation(operator, operand) {
+    return UnaryOperationNode.create(OperatorNode.create(operator), parseReferenceExpression(operand));
+}

package/dist/esm/parser/update-parser.d.ts

@@ -0,0 +1,9 @@
+import type { UpdateQueryBuilder } from '../query-builder/update-query-builder.js';
+import type { UpdateResult } from '../query-builder/update-result.js';
+import type { ShallowRecord } from '../util/type-utils.js';
+import type { ExtractTableAlias, From, FromTables, TableExpressionOrList } from './table-parser.js';
+export type UpdateTable<DB, TE extends TableExpressionOrList<DB, never>> = [
+    TE
+] extends [keyof DB] ? UpdateQueryBuilder<DB, ExtractTableAlias<DB, TE>, ExtractTableAlias<DB, TE>, UpdateResult> : [
+    TE
+] extends [`${infer T} as ${infer A}`] ? T extends keyof DB ? UpdateQueryBuilder<DB & ShallowRecord<A, DB[T]>, A, A, UpdateResult> : never : TE extends ReadonlyArray<infer T> ? UpdateQueryBuilder<From<DB, T>, FromTables<DB, never, T>, FromTables<DB, never, T>, UpdateResult> : UpdateQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, FromTables<DB, never, TE>, UpdateResult>;

package/dist/esm/parser/update-parser.js

@@ -0,0 +1,2 @@
+/// <reference types="./update-parser.d.ts" />
+export {};

package/dist/esm/parser/update-set-parser.d.ts

@@ -0,0 +1,16 @@
+import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
+import { ExpressionBuilder } from '../expression/expression-builder.js';
+import { UpdateType } from '../util/column-type.js';
+import { ValueExpression } from './value-parser.js';
+import { ExtractRawTypeFromReferenceExpression, ReferenceExpression } from './reference-parser.js';
+import { AnyColumn, DrainOuterGeneric } from '../util/type-utils.js';
+export type UpdateObject<DB, TB extends keyof DB, UT extends keyof DB = TB> = DrainOuterGeneric<{
+    [C in AnyColumn<DB, UT>]?: {
+        [T in UT]: C extends keyof DB[T] ? ValueExpression<DB, TB, UpdateType<DB[T][C]>> | undefined : never;
+    }[UT];
+}>;
+export type UpdateObjectFactory<DB, TB extends keyof DB, UT extends keyof DB> = (eb: ExpressionBuilder<DB, TB>) => UpdateObject<DB, TB, UT>;
+export type UpdateObjectExpression<DB, TB extends keyof DB, UT extends keyof DB = TB> = UpdateObject<DB, TB, UT> | UpdateObjectFactory<DB, TB, UT>;
+export type ExtractUpdateTypeFromReferenceExpression<DB, TB extends keyof DB, RE, DV = unknown> = UpdateType<ExtractRawTypeFromReferenceExpression<DB, TB, RE, DV>>;
+export declare function parseUpdate(...args: [UpdateObjectExpression<any, any, any>] | [ReferenceExpression<any, any>, ValueExpression<any, any, any>]): ReadonlyArray<ColumnUpdateNode>;
+export declare function parseUpdateObjectExpression(update: UpdateObjectExpression<any, any, any>): ReadonlyArray<ColumnUpdateNode>;

package/dist/esm/parser/update-set-parser.js

@@ -0,0 +1,23 @@
+/// <reference types="./update-set-parser.d.ts" />
+import { ColumnNode } from '../operation-node/column-node.js';
+import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
+import { expressionBuilder, } from '../expression/expression-builder.js';
+import { isFunction } from '../util/object-utils.js';
+import { parseValueExpression } from './value-parser.js';
+import { parseReferenceExpression, } from './reference-parser.js';
+export function parseUpdate(...args) {
+    if (args.length === 2) {
+        return [
+            ColumnUpdateNode.create(parseReferenceExpression(args[0]), parseValueExpression(args[1])),
+        ];
+    }
+    return parseUpdateObjectExpression(args[0]);
+}
+export function parseUpdateObjectExpression(update) {
+    const updateObj = isFunction(update) ? update(expressionBuilder()) : update;
+    return Object.entries(updateObj)
+        .filter(([_, value]) => value !== undefined)
+        .map(([key, value]) => {
+        return ColumnUpdateNode.create(ColumnNode.create(key), parseValueExpression(value));
+    });
+}

package/dist/esm/parser/value-parser.d.ts

@@ -0,0 +1,13 @@
+import { ValueNode } from '../operation-node/value-node.js';
+import { ExpressionOrFactory } from './expression-parser.js';
+import { OperationNode } from '../operation-node/operation-node.js';
+import { Expression } from '../expression/expression.js';
+import { SelectQueryBuilderExpression } from '../query-builder/select-query-builder-expression.js';
+export type ValueExpression<DB, TB extends keyof DB, V> = V | ExpressionOrFactory<DB, TB, V>;
+export type ValueExpressionOrList<DB, TB extends keyof DB, V> = ValueExpression<DB, TB, V> | ReadonlyArray<ValueExpression<DB, TB, V>>;
+export type ExtractTypeFromValueExpressionOrList<VE> = VE extends ReadonlyArray<infer AV> ? ExtractTypeFromValueExpression<AV> : ExtractTypeFromValueExpression<VE>;
+export type ExtractTypeFromValueExpression<VE> = VE extends SelectQueryBuilderExpression<Record<string, infer SV>> ? SV : VE extends Expression<infer V> ? V : VE;
+export declare function parseValueExpressionOrList(arg: ValueExpressionOrList<any, any, unknown>): OperationNode;
+export declare function parseValueExpression(exp: ValueExpression<any, any, unknown>): OperationNode;
+export declare function isSafeImmediateValue(value: unknown): value is number | boolean | null;
+export declare function parseSafeImmediateValue(value: number | boolean | null): ValueNode;

package/dist/esm/parser/value-parser.js

@@ -0,0 +1,33 @@
+/// <reference types="./value-parser.d.ts" />
+import { PrimitiveValueListNode } from '../operation-node/primitive-value-list-node.js';
+import { ValueListNode } from '../operation-node/value-list-node.js';
+import { ValueNode } from '../operation-node/value-node.js';
+import { isBoolean, isNull, isNumber, isReadonlyArray, } from '../util/object-utils.js';
+import { parseExpression, isExpressionOrFactory, } from './expression-parser.js';
+export function parseValueExpressionOrList(arg) {
+    if (isReadonlyArray(arg)) {
+        return parseValueExpressionList(arg);
+    }
+    return parseValueExpression(arg);
+}
+export function parseValueExpression(exp) {
+    if (isExpressionOrFactory(exp)) {
+        return parseExpression(exp);
+    }
+    return ValueNode.create(exp);
+}
+export function isSafeImmediateValue(value) {
+    return isNumber(value) || isBoolean(value) || isNull(value);
+}
+export function parseSafeImmediateValue(value) {
+    if (!isSafeImmediateValue(value)) {
+        throw new Error(`unsafe immediate value ${JSON.stringify(value)}`);
+    }
+    return ValueNode.createImmediate(value);
+}
+function parseValueExpressionList(arg) {
+    if (arg.some(isExpressionOrFactory)) {
+        return ValueListNode.create(arg.map((it) => parseValueExpression(it)));
+    }
+    return PrimitiveValueListNode.create(arg);
+}

package/dist/esm/parser/with-parser.d.ts

@@ -0,0 +1,45 @@
+import { UpdateQueryBuilder } from '../query-builder/update-query-builder.js';
+import { DeleteQueryBuilder } from '../query-builder/delete-query-builder.js';
+import { InsertQueryBuilder } from '../query-builder/insert-query-builder.js';
+import { QueryCreator } from '../query-creator.js';
+import { Expression } from '../expression/expression.js';
+import { ShallowRecord } from '../util/type-utils.js';
+import { CTEBuilderCallback } from '../query-builder/cte-builder.js';
+import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
+export type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
+export type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & {
+    [K in ExtractTableFromCommonTableExpressionName<CN>]: ExtractRowFromCommonTableExpressionName<CN>;
+}>) => CommonTableExpressionOutput<DB, CN>;
+export type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & {
+    [K in ExtractTableFromCommonTableExpressionName<CN>]: ExtractRowFromCommonTableExpression<CTE>;
+}>;
+type CommonTableExpressionOutput<DB, CN extends string> = Expression<ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>>;
+/**
+ * Given a common CommonTableExpression CTE extracts the row type from it.
+ *
+ * For example a CTE `(db) => db.selectFrom('person').select(['id', 'first_name'])`
+ * would result in `Pick<Person, 'id' | 'first_name'>`.
+ */
+type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends Expression<infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : never : never;
+/**
+ * Extracts 'person' from a string like 'person(id, first_name)'.
+ */
+type ExtractTableFromCommonTableExpressionName<CN extends string> = CN extends `${infer TB}(${string})` ? TB : CN;
+/**
+ * Parses a string like 'person(id, first_name)' into a type:
+ *
+ * {
+ *   id: any,
+ *   first_name: any
+ * }
+ *
+ */
+type ExtractRowFromCommonTableExpressionName<CN extends string> = CN extends `${string}(${infer CL})` ? {
+    [C in ExtractColumnNamesFromColumnList<CL>]: any;
+} : ShallowRecord<string, any>;
+/**
+ * Parses a string like 'id, first_name' into a type 'id' | 'first_name'
+ */
+type ExtractColumnNamesFromColumnList<R extends string> = R extends `${infer C}, ${infer RS}` ? C | ExtractColumnNamesFromColumnList<RS> : R;
+export declare function parseCommonTableExpression(nameOrBuilderCallback: string | CTEBuilderCallback<string>, expression: CommonTableExpression<any, string>): CommonTableExpressionNode;
+export {};

package/dist/esm/parser/with-parser.js

@@ -0,0 +1,31 @@
+/// <reference types="./with-parser.d.ts" />
+import { CommonTableExpressionNameNode } from '../operation-node/common-table-expression-name-node.js';
+import { createQueryCreator } from './parse-utils.js';
+import { isFunction } from '../util/object-utils.js';
+import { CTEBuilder } from '../query-builder/cte-builder.js';
+import { CommonTableExpressionNode } from '../operation-node/common-table-expression-node.js';
+export function parseCommonTableExpression(nameOrBuilderCallback, expression) {
+    const expressionNode = expression(createQueryCreator()).toOperationNode();
+    if (isFunction(nameOrBuilderCallback)) {
+        return nameOrBuilderCallback(cteBuilderFactory(expressionNode)).toOperationNode();
+    }
+    return CommonTableExpressionNode.create(parseCommonTableExpressionName(nameOrBuilderCallback), expressionNode);
+}
+function cteBuilderFactory(expressionNode) {
+    return (name) => {
+        return new CTEBuilder({
+            node: CommonTableExpressionNode.create(parseCommonTableExpressionName(name), expressionNode),
+        });
+    };
+}
+function parseCommonTableExpressionName(name) {
+    if (name.includes('(')) {
+        const parts = name.split(/[\(\)]/);
+        const table = parts[0];
+        const columns = parts[1].split(',').map((it) => it.trim());
+        return CommonTableExpressionNameNode.create(table, columns);
+    }
+    else {
+        return CommonTableExpressionNameNode.create(name);
+    }
+}

package/dist/esm/performance/query-analyzer.d.ts

@@ -0,0 +1,89 @@
+import type { Kysely } from '../kysely.js';
+import { Logger } from '../logging/logger.js';
+import { SchemaInfo } from '../types/index.js';
+export interface QueryMetrics {
+    query: string;
+    executionTime: number;
+    timestamp: Date;
+    table?: string;
+    operation?: string;
+}
+export interface PerformanceWarning {
+    type: 'n_plus_one' | 'missing_index' | 'slow_query' | 'full_table_scan' | 'large_result_set';
+    message: string;
+    suggestion: string;
+    query?: string;
+    table?: string;
+    severity: 'low' | 'medium' | 'high';
+}
+export interface QueryAnalyzerOptions {
+    enabled?: boolean;
+    slowQueryThreshold?: number;
+    nPlusOneDetection?: boolean;
+    missingIndexDetection?: boolean;
+    largeResultSetThreshold?: number;
+}
+/**
+ * Analyzes query performance and provides warnings for optimization
+ */
+export declare class QueryAnalyzer {
+    private db;
+    private logger;
+    private schemaInfo;
+    private options;
+    private queryHistory;
+    private recentQueries;
+    private maxHistorySize;
+    constructor(db: Kysely<any>, logger: Logger, schemaInfo: SchemaInfo, options?: QueryAnalyzerOptions);
+    /**
+     * Record a query execution for analysis
+     */
+    recordQuery(query: string, executionTime: number, resultCount?: number, table?: string): void;
+    /**
+     * Analyze a query for performance issues
+     */
+    private analyzeQuery;
+    /**
+     * Detect N+1 query patterns
+     */
+    private detectNPlusOne;
+    /**
+     * Check for missing indexes based on WHERE clauses
+     */
+    private checkForMissingIndexes;
+    /**
+     * Normalize query for comparison (remove dynamic values)
+     */
+    private normalizeQuery;
+    /**
+     * Extract operation type from query
+     */
+    private extractOperation;
+    /**
+     * Log performance warning
+     */
+    private logWarning;
+    /**
+     * Get emoji for warning type
+     */
+    private getWarningEmoji;
+    /**
+     * Get performance statistics
+     */
+    getPerformanceStats(): {
+        totalQueries: number;
+        averageExecutionTime: number;
+        slowQueries: number;
+        warningCount: {
+            [key: string]: number;
+        };
+    };
+    /**
+     * Clear query history
+     */
+    clearHistory(): void;
+    /**
+     * Update schema info for index checking
+     */
+    updateSchema(schemaInfo: SchemaInfo): void;
+}