Initial commit - Event Planner application
This commit is contained in:
mberlin
423
node_modules/@mikro-orm/sql/AbstractSqlDriver.d.ts
generated
vendored
Normal file
423
node_modules/@mikro-orm/sql/AbstractSqlDriver.d.ts
generated
vendored
Normal file
@@ -0,0 +1,423 @@
|
||||
import {
|
||||
type AnyEntity,
|
||||
type Collection,
|
||||
type Configuration,
|
||||
type ConnectionType,
|
||||
type Constructor,
|
||||
type CountOptions,
|
||||
DatabaseDriver,
|
||||
type DeleteOptions,
|
||||
type Dictionary,
|
||||
type DriverMethodOptions,
|
||||
type EntityData,
|
||||
type EntityDictionary,
|
||||
type EntityField,
|
||||
EntityManagerType,
|
||||
type EntityMetadata,
|
||||
type EntityName,
|
||||
type EntityProperty,
|
||||
type FilterQuery,
|
||||
type FindOneOptions,
|
||||
type FindOptions,
|
||||
type FormulaTable,
|
||||
type LockOptions,
|
||||
type LoggingOptions,
|
||||
type NativeInsertUpdateManyOptions,
|
||||
type NativeInsertUpdateOptions,
|
||||
type ObjectQuery,
|
||||
type Options,
|
||||
type OrderDefinition,
|
||||
type PopulateOptions,
|
||||
type PopulatePath,
|
||||
type Primary,
|
||||
type QueryOrderMap,
|
||||
type QueryResult,
|
||||
type Raw,
|
||||
RawQueryFragment,
|
||||
type StreamOptions,
|
||||
type Transaction,
|
||||
type UpsertManyOptions,
|
||||
type UpsertOptions,
|
||||
} from '@mikro-orm/core';
|
||||
import type { AbstractSqlConnection } from './AbstractSqlConnection.js';
|
||||
import type { AbstractSqlPlatform } from './AbstractSqlPlatform.js';
|
||||
import { type AnyQueryBuilder } from './query/QueryBuilder.js';
|
||||
import { type NativeQueryBuilder } from './query/NativeQueryBuilder.js';
|
||||
import { QueryType } from './query/enums.js';
|
||||
import { SqlEntityManager } from './SqlEntityManager.js';
|
||||
import type { InternalField } from './typings.js';
|
||||
/** Base class for SQL database drivers, implementing find/insert/update/delete using QueryBuilder. */
|
||||
export declare abstract class AbstractSqlDriver<
|
||||
Connection extends AbstractSqlConnection = AbstractSqlConnection,
|
||||
Platform extends AbstractSqlPlatform = AbstractSqlPlatform,
|
||||
> extends DatabaseDriver<Connection> {
|
||||
[EntityManagerType]: SqlEntityManager<this>;
|
||||
protected readonly connection: Connection;
|
||||
protected readonly replicas: Connection[];
|
||||
protected readonly platform: Platform;
|
||||
protected constructor(
|
||||
config: Configuration,
|
||||
platform: Platform,
|
||||
connection: Constructor<Connection>,
|
||||
connector: string[],
|
||||
);
|
||||
getPlatform(): Platform;
|
||||
/** Evaluates a formula callback, handling both string and Raw return values. */
|
||||
evaluateFormula(formula: (...args: any[]) => string | Raw, columns: any, table: FormulaTable): string;
|
||||
/** For TPT entities, returns ownProps (columns in this table); otherwise returns all props. */
|
||||
private getTableProps;
|
||||
/** Creates a FormulaTable object for use in formula callbacks. */
|
||||
private createFormulaTable;
|
||||
private validateSqlOptions;
|
||||
createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
|
||||
private createQueryBuilderFromOptions;
|
||||
find<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(
|
||||
entityName: EntityName<T>,
|
||||
where: ObjectQuery<T>,
|
||||
options?: FindOptions<T, P, F, E>,
|
||||
): Promise<EntityData<T>[]>;
|
||||
findOne<T extends object, P extends string = never, F extends string = PopulatePath.ALL, E extends string = never>(
|
||||
entityName: EntityName<T>,
|
||||
where: ObjectQuery<T>,
|
||||
options?: FindOneOptions<T, P, F, E>,
|
||||
): Promise<EntityData<T> | null>;
|
||||
protected hasToManyJoins<T extends object>(hint: PopulateOptions<T>, meta: EntityMetadata<T>): boolean;
|
||||
findVirtual<T extends object>(
|
||||
entityName: EntityName<T>,
|
||||
where: ObjectQuery<T>,
|
||||
options: FindOptions<T, any, any, any>,
|
||||
): Promise<EntityData<T>[]>;
|
||||
countVirtual<T extends object>(
|
||||
entityName: EntityName<T>,
|
||||
where: ObjectQuery<T>,
|
||||
options: CountOptions<T, any>,
|
||||
): Promise<number>;
|
||||
protected findFromVirtual<T extends object>(
|
||||
entityName: EntityName<T>,
|
||||
where: ObjectQuery<T>,
|
||||
options: FindOptions<T, any> | CountOptions<T, any>,
|
||||
type: QueryType,
|
||||
): Promise<EntityData<T>[] | number>;
|
||||
protected streamFromVirtual<T extends object>(
|
||||
entityName: EntityName<T>,
|
||||
where: FilterQuery<T>,
|
||||
options: StreamOptions<T, any>,
|
||||
): AsyncIterableIterator<EntityData<T>>;
|
||||
protected wrapVirtualExpressionInSubquery<T extends object>(
|
||||
meta: EntityMetadata<T>,
|
||||
expression: string,
|
||||
where: FilterQuery<T>,
|
||||
options: FindOptions<T, any>,
|
||||
type: QueryType,
|
||||
): Promise<T[] | number>;
|
||||
protected wrapVirtualExpressionInSubqueryStream<T extends object>(
|
||||
meta: EntityMetadata<T>,
|
||||
expression: string,
|
||||
where: FilterQuery<T>,
|
||||
options: FindOptions<T, any, any, any>,
|
||||
type: QueryType.SELECT,
|
||||
): AsyncIterableIterator<T>;
|
||||
/**
|
||||
* Virtual entities have no PKs, so to-many populate joins can't be deduplicated.
|
||||
* Force balanced strategy to load to-many relations via separate queries.
|
||||
*/
|
||||
private forceBalancedStrategy;
|
||||
mapResult<T extends object>(
|
||||
result: EntityData<T>,
|
||||
meta: EntityMetadata<T>,
|
||||
populate?: PopulateOptions<T>[],
|
||||
qb?: AnyQueryBuilder<T>,
|
||||
map?: Dictionary,
|
||||
): EntityData<T> | null;
|
||||
/**
|
||||
* Maps aliased columns from TPT parent tables back to their original field names.
|
||||
* TPT parent columns are selected with aliases like `parent_alias__column_name`,
|
||||
* and need to be renamed back to `column_name` for the result mapper to work.
|
||||
*/
|
||||
private mapTPTColumns;
|
||||
private mapJoinedProps;
|
||||
/**
|
||||
* Maps a single property from a joined result row into the relation pojo.
|
||||
* Handles polymorphic FKs, composite keys, Date parsing, and embedded objects.
|
||||
*/
|
||||
private mapJoinedProp;
|
||||
count<T extends object>(entityName: EntityName<T>, where: any, options?: CountOptions<T>): Promise<number>;
|
||||
nativeInsert<T extends object>(
|
||||
entityName: EntityName<T>,
|
||||
data: EntityDictionary<T>,
|
||||
options?: NativeInsertUpdateOptions<T>,
|
||||
): Promise<QueryResult<T>>;
|
||||
nativeInsertMany<T extends object>(
|
||||
entityName: EntityName<T>,
|
||||
data: EntityDictionary<T>[],
|
||||
options?: NativeInsertUpdateManyOptions<T>,
|
||||
transform?: (sql: string) => string,
|
||||
): Promise<QueryResult<T>>;
|
||||
nativeUpdate<T extends object>(
|
||||
entityName: EntityName<T>,
|
||||
where: FilterQuery<T>,
|
||||
data: EntityDictionary<T>,
|
||||
options?: NativeInsertUpdateOptions<T> & UpsertOptions<T>,
|
||||
): Promise<QueryResult<T>>;
|
||||
nativeUpdateMany<T extends object>(
|
||||
entityName: EntityName<T>,
|
||||
where: FilterQuery<T>[],
|
||||
data: EntityDictionary<T>[],
|
||||
options?: NativeInsertUpdateManyOptions<T> & UpsertManyOptions<T>,
|
||||
transform?: (sql: string, params: any[]) => string,
|
||||
): Promise<QueryResult<T>>;
|
||||
nativeDelete<T extends object>(
|
||||
entityName: EntityName<T>,
|
||||
where: FilterQuery<T> | string | any,
|
||||
options?: DeleteOptions<T>,
|
||||
): Promise<QueryResult<T>>;
|
||||
/**
|
||||
* Fast comparison for collection snapshots that are represented by PK arrays.
|
||||
* Compares scalars via `===` and fallbacks to Utils.equals()` for more complex types like Buffer.
|
||||
* Always expects the same length of the arrays, since we only compare PKs of the same entity type.
|
||||
*/
|
||||
private comparePrimaryKeyArrays;
|
||||
syncCollections<T extends object, O extends object>(
|
||||
collections: Iterable<Collection<T, O>>,
|
||||
options?: DriverMethodOptions,
|
||||
): Promise<void>;
|
||||
loadFromPivotTable<T extends object, O extends object>(
|
||||
prop: EntityProperty,
|
||||
owners: Primary<O>[][],
|
||||
where?: FilterQuery<any>,
|
||||
orderBy?: OrderDefinition<T>,
|
||||
ctx?: Transaction,
|
||||
options?: FindOptions<T, any, any, any>,
|
||||
pivotJoin?: boolean,
|
||||
): Promise<Dictionary<T[]>>;
|
||||
/**
|
||||
* Load from a polymorphic M:N pivot table.
|
||||
*/
|
||||
protected loadFromPolymorphicPivotTable<T extends object, O extends object>(
|
||||
prop: EntityProperty,
|
||||
owners: Primary<O>[][],
|
||||
where?: FilterQuery<any>,
|
||||
orderBy?: OrderDefinition<T>,
|
||||
ctx?: Transaction,
|
||||
options?: FindOptions<T, any, any, any>,
|
||||
pivotJoin?: boolean,
|
||||
): Promise<Dictionary<T[]>>;
|
||||
/**
|
||||
* Load from owner side of polymorphic M:N (e.g., Post -> Tags)
|
||||
*/
|
||||
protected loadPolymorphicPivotOwnerSide<T extends object, O extends object>(
|
||||
prop: EntityProperty,
|
||||
owners: Primary<O>[][],
|
||||
where: FilterQuery<any>,
|
||||
orderBy?: OrderDefinition<T>,
|
||||
ctx?: Transaction,
|
||||
options?: FindOptions<T, any, any, any>,
|
||||
pivotJoin?: boolean,
|
||||
inverseProp?: EntityProperty,
|
||||
): Promise<Dictionary<T[]>>;
|
||||
/**
|
||||
* Load from inverse side of polymorphic M:N (e.g., Tag -> Posts)
|
||||
* Uses single query with join via virtual relation on pivot.
|
||||
*/
|
||||
protected loadPolymorphicPivotInverseSide<T extends object, O extends object>(
|
||||
prop: EntityProperty,
|
||||
owners: Primary<O>[][],
|
||||
where: FilterQuery<any>,
|
||||
orderBy?: OrderDefinition<T>,
|
||||
ctx?: Transaction,
|
||||
options?: FindOptions<T, any, any, any>,
|
||||
): Promise<Dictionary<T[]>>;
|
||||
/**
|
||||
* Build a map from owner PKs to their related entities from pivot table results.
|
||||
*/
|
||||
private buildPivotResultMap;
|
||||
private wrapPopulateFilter;
|
||||
private getPivotOrderBy;
|
||||
execute<T extends QueryResult | EntityData<AnyEntity> | EntityData<AnyEntity>[] = EntityData<AnyEntity>[]>(
|
||||
query: string | NativeQueryBuilder | RawQueryFragment,
|
||||
params?: any[],
|
||||
method?: 'all' | 'get' | 'run',
|
||||
ctx?: Transaction,
|
||||
loggerContext?: LoggingOptions,
|
||||
): Promise<T>;
|
||||
stream<T extends object>(
|
||||
entityName: EntityName<T>,
|
||||
where: FilterQuery<T>,
|
||||
options: StreamOptions<T, any, any, any>,
|
||||
): AsyncIterableIterator<T>;
|
||||
/**
|
||||
* 1:1 owner side needs to be marked for population so QB auto-joins the owner id
|
||||
*/
|
||||
protected autoJoinOneToOneOwner<T extends object>(
|
||||
meta: EntityMetadata<T>,
|
||||
populate: PopulateOptions<T>[],
|
||||
fields?: readonly EntityField<T, any>[],
|
||||
): PopulateOptions<T>[];
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
joinedProps<T>(
|
||||
meta: EntityMetadata,
|
||||
populate: readonly PopulateOptions<T>[],
|
||||
options?: {
|
||||
strategy?: Options['loadStrategy'];
|
||||
},
|
||||
): PopulateOptions<T>[];
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
mergeJoinedResult<T extends object>(
|
||||
rawResults: EntityData<T>[],
|
||||
meta: EntityMetadata<T>,
|
||||
joinedProps: PopulateOptions<T>[],
|
||||
): EntityData<T>[];
|
||||
protected shouldHaveColumn<T, U>(
|
||||
meta: EntityMetadata<T>,
|
||||
prop: EntityProperty<U>,
|
||||
populate: readonly PopulateOptions<U>[],
|
||||
fields?: readonly InternalField<U>[],
|
||||
exclude?: readonly InternalField<U>[],
|
||||
): boolean;
|
||||
protected getFieldsForJoinedLoad<T extends object>(
|
||||
qb: AnyQueryBuilder<T>,
|
||||
meta: EntityMetadata<T>,
|
||||
options: FieldsForJoinedLoadOptions<T>,
|
||||
): InternalField<T>[];
|
||||
/**
|
||||
* Adds LEFT JOINs and fields for TPT polymorphic loading when populating a relation to a TPT base class.
|
||||
* @internal
|
||||
*/
|
||||
protected addTPTPolymorphicJoinsForRelation<T extends object>(
|
||||
qb: AnyQueryBuilder<T>,
|
||||
meta: EntityMetadata<T>,
|
||||
baseAlias: string,
|
||||
fields: InternalField<T>[],
|
||||
): void;
|
||||
/**
|
||||
* Find the alias for a TPT child table in the query builder.
|
||||
* @internal
|
||||
*/
|
||||
protected findTPTChildAlias<T extends object>(qb: AnyQueryBuilder<T>, childMeta: EntityMetadata): string | undefined;
|
||||
/**
|
||||
* Builds a CASE WHEN expression for TPT discriminator.
|
||||
* Determines concrete entity type based on which child table has a non-null PK.
|
||||
* @internal
|
||||
*/
|
||||
buildTPTDiscriminatorExpression(
|
||||
meta: EntityMetadata,
|
||||
descendants: EntityMetadata[],
|
||||
aliasMap: Dictionary<string>,
|
||||
baseAlias: string,
|
||||
): Raw;
|
||||
/**
|
||||
* Maps TPT child-specific fields during hydration.
|
||||
* When a relation points to a TPT base class, the actual entity might be a child class.
|
||||
* This method reads the discriminator to determine the concrete type and maps child-specific fields.
|
||||
* @internal
|
||||
*/
|
||||
protected mapTPTChildFields<T extends object>(
|
||||
relationPojo: EntityData<T>,
|
||||
meta: EntityMetadata<T>,
|
||||
relationAlias: string,
|
||||
qb: AnyQueryBuilder<T>,
|
||||
root: EntityData<T>,
|
||||
): void;
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
mapPropToFieldNames<T extends object>(
|
||||
qb: AnyQueryBuilder<T>,
|
||||
prop: EntityProperty<T>,
|
||||
tableAlias: string,
|
||||
meta: EntityMetadata<T>,
|
||||
schema?: string,
|
||||
explicitFields?: readonly InternalField<T>[],
|
||||
): InternalField<T>[];
|
||||
/** @internal */
|
||||
createQueryBuilder<T extends object>(
|
||||
entityName: EntityName<T> | AnyQueryBuilder<T>,
|
||||
ctx?: Transaction,
|
||||
preferredConnectionType?: ConnectionType,
|
||||
convertCustomTypes?: boolean,
|
||||
loggerContext?: LoggingOptions,
|
||||
alias?: string,
|
||||
em?: SqlEntityManager,
|
||||
): AnyQueryBuilder<T>;
|
||||
protected resolveConnectionType(args: { ctx?: Transaction; connectionType?: ConnectionType }): ConnectionType;
|
||||
protected extractManyToMany<T>(meta: EntityMetadata<T>, data: EntityDictionary<T>): EntityData<T>;
|
||||
protected processManyToMany<T extends object>(
|
||||
meta: EntityMetadata<T>,
|
||||
pks: Primary<T>[],
|
||||
collections: EntityData<T>,
|
||||
clear: boolean,
|
||||
options?: DriverMethodOptions,
|
||||
): Promise<void>;
|
||||
lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
|
||||
protected buildPopulateWhere<T extends object>(
|
||||
meta: EntityMetadata<T>,
|
||||
joinedProps: PopulateOptions<T>[],
|
||||
options: Pick<FindOptions<any>, 'populateWhere'>,
|
||||
): ObjectQuery<T>;
|
||||
/**
|
||||
* Builds a UNION ALL (or UNION) subquery from `unionWhere` branches and merges it
|
||||
* into the main WHERE as `pk IN (branch_1 UNION ALL branch_2 ...)`.
|
||||
* Each branch is planned independently by the database, enabling per-table index usage.
|
||||
*/
|
||||
protected applyUnionWhere<T extends object>(
|
||||
meta: EntityMetadata<T>,
|
||||
where: ObjectQuery<T>,
|
||||
options: FindOptions<T, any, any, any> | CountOptions<T> | NativeInsertUpdateOptions<T> | DeleteOptions<T>,
|
||||
forDml?: boolean,
|
||||
): Promise<ObjectQuery<T>>;
|
||||
protected buildOrderBy<T extends object>(
|
||||
qb: AnyQueryBuilder<T>,
|
||||
meta: EntityMetadata<T>,
|
||||
populate: PopulateOptions<T>[],
|
||||
options: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>,
|
||||
): QueryOrderMap<T>[];
|
||||
protected buildPopulateOrderBy<T extends object>(
|
||||
qb: AnyQueryBuilder<T>,
|
||||
meta: EntityMetadata<T>,
|
||||
populateOrderBy: QueryOrderMap<T>[],
|
||||
parentPath: string,
|
||||
explicit: boolean,
|
||||
parentAlias?: string,
|
||||
): QueryOrderMap<T>[];
|
||||
protected buildJoinedPropsOrderBy<T extends object>(
|
||||
qb: AnyQueryBuilder<T>,
|
||||
meta: EntityMetadata<T>,
|
||||
populate: PopulateOptions<T>[],
|
||||
options?: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>,
|
||||
parentPath?: string,
|
||||
): QueryOrderMap<T>[];
|
||||
private buildToManyOrderBy;
|
||||
protected normalizeFields<T extends object>(fields: InternalField<T>[], prefix?: string): string[];
|
||||
protected processField<T extends object>(
|
||||
meta: EntityMetadata<T>,
|
||||
prop: EntityProperty<T> | undefined,
|
||||
field: string,
|
||||
ret: InternalField<T>[],
|
||||
): void;
|
||||
protected buildFields<T extends object>(
|
||||
meta: EntityMetadata<T>,
|
||||
populate: PopulateOptions<T>[],
|
||||
joinedProps: PopulateOptions<T>[],
|
||||
qb: AnyQueryBuilder<T>,
|
||||
alias: string,
|
||||
options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>,
|
||||
schema?: string,
|
||||
): InternalField<T>[];
|
||||
}
|
||||
interface FieldsForJoinedLoadOptions<T extends object> {
|
||||
explicitFields?: readonly InternalField<T>[];
|
||||
exclude?: readonly InternalField<T>[];
|
||||
populate?: readonly PopulateOptions<T>[];
|
||||
strategy?: Options['loadStrategy'];
|
||||
populateWhere?: FindOptions<any>['populateWhere'];
|
||||
populateFilter?: FindOptions<any>['populateFilter'];
|
||||
parentTableAlias: string;
|
||||
parentJoinPath?: string;
|
||||
count?: boolean;
|
||||
schema?: string;
|
||||
}
|
||||
export {};
|
||||
Reference in New Issue
Block a user