Initial commit - Event Planner application
This commit is contained in:
mberlin
911
node_modules/@mikro-orm/core/EntityManager.d.ts
generated
vendored
Normal file
911
node_modules/@mikro-orm/core/EntityManager.d.ts
generated
vendored
Normal file
@@ -0,0 +1,911 @@
|
||||
import { type Configuration } from './utils/Configuration.js';
|
||||
import { Cursor } from './utils/Cursor.js';
|
||||
import { EntityFactory } from './entity/EntityFactory.js';
|
||||
import { type AssignOptions } from './entity/EntityAssigner.js';
|
||||
import { type EntityRepository } from './entity/EntityRepository.js';
|
||||
import { EntityLoader, type EntityLoaderOptions } from './entity/EntityLoader.js';
|
||||
import { Reference } from './entity/Reference.js';
|
||||
import { UnitOfWork } from './unit-of-work/UnitOfWork.js';
|
||||
import type {
|
||||
CountOptions,
|
||||
DeleteOptions,
|
||||
FilterOptions,
|
||||
FindAllOptions,
|
||||
FindByCursorOptions,
|
||||
FindOneOptions,
|
||||
FindOneOrFailOptions,
|
||||
FindOptions,
|
||||
GetReferenceOptions,
|
||||
IDatabaseDriver,
|
||||
LockOptions,
|
||||
NativeInsertUpdateOptions,
|
||||
StreamOptions,
|
||||
UpdateOptions,
|
||||
UpsertManyOptions,
|
||||
UpsertOptions,
|
||||
} from './drivers/IDatabaseDriver.js';
|
||||
import type {
|
||||
AnyString,
|
||||
ArrayElement,
|
||||
AutoPath,
|
||||
ConnectionType,
|
||||
Dictionary,
|
||||
EntityClass,
|
||||
EntityData,
|
||||
EntityDictionary,
|
||||
EntityDTO,
|
||||
EntityMetadata,
|
||||
EntityName,
|
||||
FilterDef,
|
||||
FilterQuery,
|
||||
FromEntityType,
|
||||
GetRepository,
|
||||
IHydrator,
|
||||
IsSubset,
|
||||
Loaded,
|
||||
MergeLoaded,
|
||||
MergeSelected,
|
||||
ObjectQuery,
|
||||
PopulateOptions,
|
||||
Primary,
|
||||
Ref,
|
||||
RequiredEntityData,
|
||||
UnboxArray,
|
||||
} from './typings.js';
|
||||
import { FlushMode, LockMode, PopulatePath, type TransactionOptions } from './enums.js';
|
||||
import type { MetadataStorage } from './metadata/MetadataStorage.js';
|
||||
import type { Transaction } from './connections/Connection.js';
|
||||
import { EventManager } from './events/EventManager.js';
|
||||
import type { EntityComparator } from './utils/EntityComparator.js';
|
||||
/**
|
||||
* The EntityManager is the central access point to ORM functionality. It is a facade to all different ORM subsystems
|
||||
* such as UnitOfWork, Query Language, and Repository API.
|
||||
* @template {IDatabaseDriver} Driver current driver type
|
||||
*/
|
||||
export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDriver> {
|
||||
#private;
|
||||
readonly config: Configuration;
|
||||
protected readonly driver: Driver;
|
||||
protected readonly metadata: MetadataStorage;
|
||||
protected readonly eventManager: EventManager;
|
||||
/** @internal */
|
||||
readonly '~entities'?: unknown;
|
||||
/** @internal */
|
||||
readonly _id: number;
|
||||
/** Whether this is the global (root) EntityManager instance. */
|
||||
readonly global = false;
|
||||
/** The context name of this EntityManager, derived from the ORM configuration. */
|
||||
readonly name: string;
|
||||
protected loggerContext?: Dictionary;
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
constructor(
|
||||
config: Configuration,
|
||||
driver: Driver,
|
||||
metadata: MetadataStorage,
|
||||
useContext?: boolean,
|
||||
eventManager?: EventManager,
|
||||
);
|
||||
/**
|
||||
* Gets the Driver instance used by this EntityManager.
|
||||
* Driver is singleton, for one MikroORM instance, only one driver is created.
|
||||
*/
|
||||
getDriver(): Driver;
|
||||
/**
|
||||
* Gets the Connection instance, by default returns write connection
|
||||
*/
|
||||
getConnection(type?: ConnectionType): ReturnType<Driver['getConnection']>;
|
||||
/**
|
||||
* Gets the platform instance. Just like the driver, platform is singleton, one for a MikroORM instance.
|
||||
*/
|
||||
getPlatform(): ReturnType<Driver['getPlatform']>;
|
||||
/**
|
||||
* Gets repository for given entity. You can pass either string name or entity class reference.
|
||||
*/
|
||||
getRepository<Entity extends object, Repository extends EntityRepository<Entity> = EntityRepository<Entity>>(
|
||||
entityName: EntityName<Entity>,
|
||||
): GetRepository<Entity, Repository>;
|
||||
/**
|
||||
* Shortcut for `em.getRepository()`.
|
||||
*/
|
||||
repo<Entity extends object, Repository extends EntityRepository<Entity> = EntityRepository<Entity>>(
|
||||
entityName: EntityName<Entity>,
|
||||
): GetRepository<Entity, Repository>;
|
||||
/**
|
||||
* Finds all entities matching your `where` query. You can pass additional options via the `options` parameter.
|
||||
*/
|
||||
find<
|
||||
Entity extends object,
|
||||
Hint extends string = never,
|
||||
Fields extends string = PopulatePath.ALL,
|
||||
Excludes extends string = never,
|
||||
>(
|
||||
entityName: EntityName<Entity>,
|
||||
where: FilterQuery<NoInfer<Entity>>,
|
||||
options?: FindOptions<Entity, Hint, Fields, Excludes>,
|
||||
): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
|
||||
/**
|
||||
* Finds all entities and returns an async iterable (async generator) that yields results one by one.
|
||||
* The results are merged and mapped to entity instances, without adding them to the identity map.
|
||||
* You can disable merging by passing the options `{ mergeResults: false }`.
|
||||
* With `mergeResults` disabled, to-many collections will contain at most one item, and you will get duplicate
|
||||
* root entities when there are multiple items in the populated collection.
|
||||
* This is useful for processing large datasets without loading everything into memory at once.
|
||||
*
|
||||
* ```ts
|
||||
* const stream = em.stream(Book, { populate: ['author'] });
|
||||
*
|
||||
* for await (const book of stream) {
|
||||
* // book is an instance of Book entity
|
||||
* console.log(book.title, book.author.name);
|
||||
* }
|
||||
* ```
|
||||
*/
|
||||
stream<
|
||||
Entity extends object,
|
||||
Hint extends string = never,
|
||||
Fields extends string = '*',
|
||||
Excludes extends string = never,
|
||||
>(
|
||||
entityName: EntityName<Entity>,
|
||||
options?: StreamOptions<NoInfer<Entity>, Hint, Fields, Excludes>,
|
||||
): AsyncIterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
|
||||
/**
|
||||
* Finds all entities of given type, optionally matching the `where` condition provided in the `options` parameter.
|
||||
*/
|
||||
findAll<
|
||||
Entity extends object,
|
||||
Hint extends string = never,
|
||||
Fields extends string = '*',
|
||||
Excludes extends string = never,
|
||||
>(
|
||||
entityName: EntityName<Entity>,
|
||||
options?: FindAllOptions<NoInfer<Entity>, Hint, Fields, Excludes>,
|
||||
): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
|
||||
private getPopulateWhere;
|
||||
/**
|
||||
* Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
|
||||
*/
|
||||
addFilter<T extends EntityName | readonly EntityName[]>(options: FilterDef<T>): void;
|
||||
/**
|
||||
* Sets filter parameter values globally inside context defined by this entity manager.
|
||||
* If you want to set shared value for all contexts, be sure to use the root entity manager.
|
||||
*/
|
||||
setFilterParams(name: string, args: Dictionary): void;
|
||||
/**
|
||||
* Returns filter parameters for given filter set in this context.
|
||||
*/
|
||||
getFilterParams<T extends Dictionary = Dictionary>(name: string): T;
|
||||
/**
|
||||
* Sets logger context for this entity manager.
|
||||
*/
|
||||
setLoggerContext(context: Dictionary): void;
|
||||
/**
|
||||
* Gets logger context for this entity manager.
|
||||
*/
|
||||
getLoggerContext<T extends Dictionary = Dictionary>(options?: { disableContextResolution?: boolean }): T;
|
||||
/** Sets the flush mode for this EntityManager. Pass `undefined` to reset to the global default. */
|
||||
setFlushMode(flushMode?: FlushMode | `${FlushMode}`): void;
|
||||
protected processWhere<
|
||||
Entity extends object,
|
||||
Hint extends string = never,
|
||||
Fields extends string = '*',
|
||||
Excludes extends string = never,
|
||||
>(
|
||||
entityName: EntityName<Entity>,
|
||||
where: FilterQuery<Entity>,
|
||||
options: FindOptions<Entity, Hint, Fields, Excludes> | FindOneOptions<Entity, Hint, Fields, Excludes>,
|
||||
type: 'read' | 'update' | 'delete',
|
||||
): Promise<FilterQuery<Entity>>;
|
||||
protected processUnionWhere<Entity extends object, Hint extends string = never>(
|
||||
entityName: EntityName<Entity>,
|
||||
options:
|
||||
| FindOptions<Entity, Hint, any, any>
|
||||
| CountOptions<Entity, Hint>
|
||||
| UpdateOptions<Entity>
|
||||
| DeleteOptions<Entity>,
|
||||
type: 'read' | 'update' | 'delete',
|
||||
): Promise<void>;
|
||||
protected applyDiscriminatorCondition<Entity extends object>(
|
||||
entityName: EntityName<Entity>,
|
||||
where: FilterQuery<Entity>,
|
||||
): FilterQuery<Entity>;
|
||||
protected createPopulateWhere<Entity extends object>(
|
||||
cond: ObjectQuery<Entity>,
|
||||
options: FindOptions<Entity, any, any, any> | FindOneOptions<Entity, any, any, any> | CountOptions<Entity, any>,
|
||||
): ObjectQuery<Entity>;
|
||||
protected getJoinedFilters<Entity extends object>(
|
||||
meta: EntityMetadata<Entity>,
|
||||
options: FindOptions<Entity, any, any, any> | FindOneOptions<Entity, any, any, any>,
|
||||
): Promise<ObjectQuery<Entity> | undefined>;
|
||||
/**
|
||||
* When filters are active on M:1 or 1:1 relations, we need to ref join them eagerly as they might affect the FK value.
|
||||
*/
|
||||
protected autoJoinRefsForFilters<T extends object>(
|
||||
meta: EntityMetadata<T>,
|
||||
options: FindOptions<T, any, any, any> | FindOneOptions<T, any, any, any>,
|
||||
parent?: {
|
||||
class: EntityClass;
|
||||
propName: string;
|
||||
},
|
||||
): Promise<void>;
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
applyFilters<Entity extends object>(
|
||||
entityName: EntityName<Entity>,
|
||||
where: FilterQuery<Entity> | undefined,
|
||||
options: FilterOptions | undefined,
|
||||
type: 'read' | 'update' | 'delete',
|
||||
findOptions?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>,
|
||||
): Promise<FilterQuery<Entity> | undefined>;
|
||||
/**
|
||||
* Calls `em.find()` and `em.count()` with the same arguments (where applicable) and returns the results as tuple
|
||||
* where the first element is the array of entities, and the second is the count.
|
||||
*/
|
||||
findAndCount<
|
||||
Entity extends object,
|
||||
Hint extends string = never,
|
||||
Fields extends string = '*',
|
||||
Excludes extends string = never,
|
||||
>(
|
||||
entityName: EntityName<Entity>,
|
||||
where: FilterQuery<NoInfer<Entity>>,
|
||||
options?: FindOptions<Entity, Hint, Fields, Excludes>,
|
||||
): Promise<[Loaded<Entity, Hint, Fields, Excludes>[], number]>;
|
||||
/**
|
||||
* Calls `em.find()` and `em.count()` with the same arguments (where applicable) and returns the results as {@apilink Cursor} object.
|
||||
* Supports `before`, `after`, `first` and `last` options while disallowing `limit` and `offset`. Explicit `orderBy` option
|
||||
* is required.
|
||||
*
|
||||
* Use `first` and `after` for forward pagination, or `last` and `before` for backward pagination.
|
||||
*
|
||||
* - `first` and `last` are numbers and serve as an alternative to `offset`, those options are mutually exclusive, use only one at a time
|
||||
* - `before` and `after` specify the previous cursor value, it can be one of the:
|
||||
* - `Cursor` instance
|
||||
* - opaque string provided by `startCursor/endCursor` properties
|
||||
* - POJO/entity instance
|
||||
*
|
||||
* ```ts
|
||||
* const currentCursor = await em.findByCursor(User, {
|
||||
* first: 10,
|
||||
* after: previousCursor, // cursor instance
|
||||
* orderBy: { id: 'desc' },
|
||||
* });
|
||||
*
|
||||
* // to fetch next page
|
||||
* const nextCursor = await em.findByCursor(User, {
|
||||
* first: 10,
|
||||
* after: currentCursor.endCursor, // opaque string
|
||||
* orderBy: { id: 'desc' },
|
||||
* });
|
||||
*
|
||||
* // to fetch next page
|
||||
* const nextCursor2 = await em.findByCursor(User, {
|
||||
* first: 10,
|
||||
* after: { id: lastSeenId }, // entity-like POJO
|
||||
* orderBy: { id: 'desc' },
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* The options also support an `includeCount` (true by default) option. If set to false, the `totalCount` is not
|
||||
* returned as part of the cursor. This is useful for performance reason, when you don't care about the total number
|
||||
* of pages.
|
||||
*
|
||||
* The `Cursor` object provides the following interface:
|
||||
*
|
||||
* ```ts
|
||||
* Cursor<User> {
|
||||
* items: [
|
||||
* User { ... },
|
||||
* User { ... },
|
||||
* User { ... },
|
||||
* ],
|
||||
* totalCount: 50, // not included if `includeCount: false`
|
||||
* startCursor: 'WzRd',
|
||||
* endCursor: 'WzZd',
|
||||
* hasPrevPage: true,
|
||||
* hasNextPage: true,
|
||||
* }
|
||||
* ```
|
||||
*/
|
||||
findByCursor<
|
||||
Entity extends object,
|
||||
Hint extends string = never,
|
||||
Fields extends string = '*',
|
||||
Excludes extends string = never,
|
||||
IncludeCount extends boolean = true,
|
||||
>(
|
||||
entityName: EntityName<Entity>,
|
||||
options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>,
|
||||
): Promise<Cursor<Entity, Hint, Fields, Excludes, IncludeCount>>;
|
||||
/**
|
||||
* Refreshes the persistent state of an entity from the database, overriding any local changes that have not yet been
|
||||
* persisted. Returns the same entity instance (same object reference), but re-hydrated. If the entity is no longer
|
||||
* in database, the method throws an error just like `em.findOneOrFail()` (and respects the same config options).
|
||||
*/
|
||||
refreshOrFail<
|
||||
Entity extends object,
|
||||
Naked extends FromEntityType<Entity> = FromEntityType<Entity>,
|
||||
Hint extends string = never,
|
||||
Fields extends string = '*',
|
||||
Excludes extends string = never,
|
||||
>(
|
||||
entity: Entity,
|
||||
options?: FindOneOrFailOptions<Entity, Hint, Fields, Excludes>,
|
||||
): Promise<MergeLoaded<Entity, Naked, Hint, Fields, Excludes, true>>;
|
||||
/**
|
||||
* Refreshes the persistent state of an entity from the database, overriding any local changes that have not yet been
|
||||
* persisted. Returns the same entity instance (same object reference), but re-hydrated. If the entity is no longer
|
||||
* in database, the method returns `null`.
|
||||
*/
|
||||
refresh<
|
||||
Entity extends object,
|
||||
Naked extends FromEntityType<Entity> = FromEntityType<Entity>,
|
||||
Hint extends string = never,
|
||||
Fields extends string = '*',
|
||||
Excludes extends string = never,
|
||||
>(
|
||||
entity: Entity,
|
||||
options?: FindOneOptions<Entity, Hint, Fields, Excludes>,
|
||||
): Promise<MergeLoaded<Entity, Naked, Hint, Fields, Excludes, true> | null>;
|
||||
/**
|
||||
* Finds first entity matching your `where` query.
|
||||
*/
|
||||
findOne<
|
||||
Entity extends object,
|
||||
Hint extends string = never,
|
||||
Fields extends string = '*',
|
||||
Excludes extends string = never,
|
||||
>(
|
||||
entityName: EntityName<Entity>,
|
||||
where: FilterQuery<NoInfer<Entity>>,
|
||||
options?: FindOneOptions<Entity, Hint, Fields, Excludes>,
|
||||
): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
|
||||
/**
|
||||
* Finds first entity matching your `where` query. If nothing found, it will throw an error.
|
||||
* If the `strict` option is specified and nothing is found or more than one matching entity is found, it will throw an error.
|
||||
* You can override the factory for creating this method via `options.failHandler` locally
|
||||
* or via `Configuration.findOneOrFailHandler` (`findExactlyOneOrFailHandler` when specifying `strict`) globally.
|
||||
*/
|
||||
findOneOrFail<
|
||||
Entity extends object,
|
||||
Hint extends string = never,
|
||||
Fields extends string = '*',
|
||||
Excludes extends string = never,
|
||||
>(
|
||||
entityName: EntityName<Entity>,
|
||||
where: FilterQuery<NoInfer<Entity>>,
|
||||
options?: FindOneOrFailOptions<Entity, Hint, Fields, Excludes>,
|
||||
): Promise<Loaded<Entity, Hint, Fields, Excludes>>;
|
||||
/**
|
||||
* Creates or updates the entity, based on whether it is already present in the database.
|
||||
* This method performs an `insert on conflict merge` query ensuring the database is in sync, returning a managed
|
||||
* entity instance. The method accepts either `entityName` together with the entity `data`, or just entity instance.
|
||||
*
|
||||
* ```ts
|
||||
* // insert into "author" ("age", "email") values (33, 'foo@bar.com') on conflict ("email") do update set "age" = 41
|
||||
* const author = await em.upsert(Author, { email: 'foo@bar.com', age: 33 });
|
||||
* ```
|
||||
*
|
||||
* The entity data needs to contain either the primary key, or any other unique property. Let's consider the following example, where `Author.email` is a unique property:
|
||||
*
|
||||
* ```ts
|
||||
* // insert into "author" ("age", "email") values (33, 'foo@bar.com') on conflict ("email") do update set "age" = 41
|
||||
* // select "id" from "author" where "email" = 'foo@bar.com'
|
||||
* const author = await em.upsert(Author, { email: 'foo@bar.com', age: 33 });
|
||||
* ```
|
||||
*
|
||||
* Depending on the driver support, this will either use a returning query, or a separate select query, to fetch the primary key if it's missing from the `data`.
|
||||
*
|
||||
* If the entity is already present in current context, there won't be any queries - instead, the entity data will be assigned and an explicit `flush` will be required for those changes to be persisted.
|
||||
*/
|
||||
upsert<Entity extends object, Fields extends string = any>(
|
||||
entityNameOrEntity: EntityName<Entity> | Entity,
|
||||
data?: EntityData<Entity> | NoInfer<Entity>,
|
||||
options?: UpsertOptions<Entity, Fields>,
|
||||
): Promise<Entity>;
|
||||
/**
|
||||
* Creates or updates the entity, based on whether it is already present in the database.
|
||||
* This method performs an `insert on conflict merge` query ensuring the database is in sync, returning a managed
|
||||
* entity instance. The method accepts either `entityName` together with the entity `data`, or just entity instance.
|
||||
*
|
||||
* ```ts
|
||||
* // insert into "author" ("age", "email") values (33, 'foo@bar.com') on conflict ("email") do update set "age" = 41
|
||||
* const authors = await em.upsertMany(Author, [{ email: 'foo@bar.com', age: 33 }, ...]);
|
||||
* ```
|
||||
*
|
||||
* The entity data needs to contain either the primary key, or any other unique property. Let's consider the following example, where `Author.email` is a unique property:
|
||||
*
|
||||
* ```ts
|
||||
* // insert into "author" ("age", "email") values (33, 'foo@bar.com'), (666, 'lol@lol.lol') on conflict ("email") do update set "age" = excluded."age"
|
||||
* // select "id" from "author" where "email" = 'foo@bar.com'
|
||||
* const author = await em.upsertMany(Author, [
|
||||
* { email: 'foo@bar.com', age: 33 },
|
||||
* { email: 'lol@lol.lol', age: 666 },
|
||||
* ]);
|
||||
* ```
|
||||
*
|
||||
* Depending on the driver support, this will either use a returning query, or a separate select query, to fetch the primary key if it's missing from the `data`.
|
||||
*
|
||||
* If the entity is already present in current context, there won't be any queries - instead, the entity data will be assigned and an explicit `flush` will be required for those changes to be persisted.
|
||||
*/
|
||||
upsertMany<Entity extends object, Fields extends string = any>(
|
||||
entityNameOrEntity: EntityName<Entity> | Entity[],
|
||||
data?: (EntityData<Entity> | NoInfer<Entity>)[],
|
||||
options?: UpsertManyOptions<Entity, Fields>,
|
||||
): Promise<Entity[]>;
|
||||
/**
|
||||
* Runs your callback wrapped inside a database transaction.
|
||||
*
|
||||
* If a transaction is already active, a new savepoint (nested transaction) will be created by default. This behavior
|
||||
* can be controlled via the `propagation` option. Use the provided EntityManager instance for all operations that
|
||||
* should be part of the transaction. You can safely use a global EntityManager instance from a DI container, as this
|
||||
* method automatically creates an async context for the transaction.
|
||||
*
|
||||
* **Concurrency note:** When running multiple transactions concurrently (e.g. in parallel requests or jobs), use the
|
||||
* `clear: true` option. This ensures the callback runs in a clear fork of the EntityManager, providing full isolation
|
||||
* between concurrent transactional handlers. Using `clear: true` is an alternative to forking explicitly and calling
|
||||
* the method on the new fork – it already provides the necessary isolation for safe concurrent usage.
|
||||
*
|
||||
* **Propagation note:** Changes made within a transaction (whether top-level or nested) are always propagated to the
|
||||
* parent context, unless the parent context is a global one. If you want to avoid that, fork the EntityManager first
|
||||
* and then call this method on the fork.
|
||||
*
|
||||
* **Example:**
|
||||
* ```ts
|
||||
* await em.transactional(async (em) => {
|
||||
* const author = new Author('Jon');
|
||||
* em.persist(author);
|
||||
* // flush is called automatically at the end of the callback
|
||||
* });
|
||||
* ```
|
||||
*/
|
||||
transactional<T>(cb: (em: this) => T | Promise<T>, options?: TransactionOptions): Promise<T>;
|
||||
/**
|
||||
* Starts new transaction bound to this EntityManager. Use `ctx` parameter to provide the parent when nesting transactions.
|
||||
*/
|
||||
begin(options?: Omit<TransactionOptions, 'ignoreNestedTransactions'>): Promise<void>;
|
||||
/**
|
||||
* Commits the transaction bound to this EntityManager. Flushes before doing the actual commit query.
|
||||
*/
|
||||
commit(): Promise<void>;
|
||||
/**
|
||||
* Rollbacks the transaction bound to this EntityManager.
|
||||
*/
|
||||
rollback(): Promise<void>;
|
||||
/**
|
||||
* Runs your callback wrapped inside a database transaction.
|
||||
*/
|
||||
lock<T extends object>(entity: T, lockMode: LockMode, options?: LockOptions | number | Date): Promise<void>;
|
||||
/**
|
||||
* Fires native insert query. Calling this has no side effects on the context (identity map).
|
||||
*/
|
||||
insert<Entity extends object>(
|
||||
entityNameOrEntity: EntityName<Entity> | Entity,
|
||||
data?: RequiredEntityData<Entity> | Entity,
|
||||
options?: NativeInsertUpdateOptions<Entity>,
|
||||
): Promise<Primary<Entity>>;
|
||||
/**
|
||||
* Fires native multi-insert query. Calling this has no side effects on the context (identity map).
|
||||
*/
|
||||
insertMany<Entity extends object>(
|
||||
entityNameOrEntities: EntityName<Entity> | Entity[],
|
||||
data?: RequiredEntityData<Entity>[] | Entity[],
|
||||
options?: NativeInsertUpdateOptions<Entity>,
|
||||
): Promise<Primary<Entity>[]>;
|
||||
/**
|
||||
* Fires native update query. Calling this has no side effects on the context (identity map).
|
||||
*/
|
||||
nativeUpdate<Entity extends object>(
|
||||
entityName: EntityName<Entity>,
|
||||
where: FilterQuery<NoInfer<Entity>>,
|
||||
data: EntityData<Entity>,
|
||||
options?: UpdateOptions<Entity>,
|
||||
): Promise<number>;
|
||||
/**
|
||||
* Fires native delete query. Calling this has no side effects on the context (identity map).
|
||||
*/
|
||||
nativeDelete<Entity extends object>(
|
||||
entityName: EntityName<Entity>,
|
||||
where: FilterQuery<NoInfer<Entity>>,
|
||||
options?: DeleteOptions<Entity>,
|
||||
): Promise<number>;
|
||||
/**
|
||||
* Maps raw database result to an entity and merges it to this EntityManager.
|
||||
*/
|
||||
map<Entity extends object>(
|
||||
entityName: EntityName<Entity>,
|
||||
result: EntityDictionary<Entity>,
|
||||
options?: {
|
||||
schema?: string;
|
||||
},
|
||||
): Entity;
|
||||
/**
|
||||
* Merges given entity to this EntityManager so it becomes managed. You can force refreshing of existing entities
|
||||
* via second parameter. By default, it will return already loaded entities without modifying them.
|
||||
*/
|
||||
merge<Entity extends object>(entity: Entity, options?: MergeOptions): Entity;
|
||||
/**
|
||||
* Merges given entity to this EntityManager so it becomes managed. You can force refreshing of existing entities
|
||||
* via second parameter. By default, it will return already loaded entities without modifying them.
|
||||
*/
|
||||
merge<Entity extends object>(
|
||||
entityName: EntityName<Entity>,
|
||||
data: EntityData<Entity> | EntityDTO<Entity>,
|
||||
options?: MergeOptions,
|
||||
): Entity;
|
||||
/**
|
||||
* Creates new instance of given entity and populates it with given data.
|
||||
* The entity constructor will be used unless you provide `{ managed: true }` in the `options` parameter.
|
||||
* The constructor will be given parameters based on the defined constructor of the entity. If the constructor
|
||||
* parameter matches a property name, its value will be extracted from `data`. If no matching property exists,
|
||||
* the whole `data` parameter will be passed. This means we can also define `constructor(data: Partial<T>)` and
|
||||
* `em.create()` will pass the data into it (unless we have a property named `data` too).
|
||||
*
|
||||
* The parameters are strictly checked, you need to provide all required properties. You can use `OptionalProps`
|
||||
* symbol to omit some properties from this check without making them optional. Alternatively, use `partial: true`
|
||||
* in the options to disable the strict checks for required properties. This option has no effect on runtime.
|
||||
*
|
||||
* The newly created entity will be automatically marked for persistence via `em.persist` unless you disable this
|
||||
* behavior, either locally via `persist: false` option, or globally via `persistOnCreate` ORM config option.
|
||||
*/
|
||||
create<
|
||||
Entity extends object,
|
||||
Convert extends boolean = false,
|
||||
Data extends RequiredEntityData<Entity, never, Convert> = RequiredEntityData<Entity, never, Convert>,
|
||||
>(
|
||||
entityName: EntityName<Entity>,
|
||||
data: Data & IsSubset<RequiredEntityData<Entity, never, Convert>, Data>,
|
||||
options?: CreateOptions<Convert>,
|
||||
): Entity;
|
||||
/**
|
||||
* Creates new instance of given entity and populates it with given data.
|
||||
* The entity constructor will be used unless you provide `{ managed: true }` in the `options` parameter.
|
||||
* The constructor will be given parameters based on the defined constructor of the entity. If the constructor
|
||||
* parameter matches a property name, its value will be extracted from `data`. If no matching property exists,
|
||||
* the whole `data` parameter will be passed. This means we can also define `constructor(data: Partial<T>)` and
|
||||
* `em.create()` will pass the data into it (unless we have a property named `data` too).
|
||||
*
|
||||
* The parameters are strictly checked, you need to provide all required properties. You can use `OptionalProps`
|
||||
* symbol to omit some properties from this check without making them optional. Alternatively, use `partial: true`
|
||||
* in the options to disable the strict checks for required properties. This option has no effect on runtime.
|
||||
*
|
||||
* The newly created entity will be automatically marked for persistence via `em.persist` unless you disable this
|
||||
* behavior, either locally via `persist: false` option, or globally via `persistOnCreate` ORM config option.
|
||||
*/
|
||||
create<
|
||||
Entity extends object,
|
||||
Convert extends boolean = false,
|
||||
Data extends EntityData<Entity, Convert> = EntityData<Entity, Convert>,
|
||||
>(
|
||||
entityName: EntityName<Entity>,
|
||||
data: Data & IsSubset<EntityData<Entity, Convert>, Data>,
|
||||
options: CreateOptions<Convert> & {
|
||||
partial: true;
|
||||
},
|
||||
): Entity;
|
||||
/**
|
||||
* Shortcut for `wrap(entity).assign(data, { em })`
|
||||
*/
|
||||
assign<
|
||||
Entity extends object,
|
||||
Naked extends FromEntityType<Entity> = FromEntityType<Entity>,
|
||||
Convert extends boolean = false,
|
||||
Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> =
|
||||
| EntityData<Naked, Convert>
|
||||
| Partial<EntityDTO<Naked>>,
|
||||
>(
|
||||
entity: Entity | Partial<Entity>,
|
||||
data: Data & IsSubset<EntityData<Naked, Convert>, Data>,
|
||||
options?: AssignOptions<Convert>,
|
||||
): MergeSelected<Entity, Naked, keyof Data & string>;
|
||||
/**
|
||||
* Gets a reference to the entity identified by the given type and alternate key property without actually loading it.
|
||||
* The key option specifies which property to use for identity map lookup instead of the primary key.
|
||||
*/
|
||||
getReference<Entity extends object, K extends string & keyof Entity>(
|
||||
entityName: EntityName<Entity>,
|
||||
id: Entity[K],
|
||||
options: Omit<GetReferenceOptions, 'key' | 'wrapped'> & {
|
||||
key: K;
|
||||
wrapped: true;
|
||||
},
|
||||
): Ref<Entity>;
|
||||
/**
|
||||
* Gets a reference to the entity identified by the given type and alternate key property without actually loading it.
|
||||
* The key option specifies which property to use for identity map lookup instead of the primary key.
|
||||
*/
|
||||
getReference<Entity extends object, K extends string & keyof Entity>(
|
||||
entityName: EntityName<Entity>,
|
||||
id: Entity[K],
|
||||
options: Omit<GetReferenceOptions, 'key'> & {
|
||||
key: K;
|
||||
wrapped?: false;
|
||||
},
|
||||
): Entity;
|
||||
/**
|
||||
* Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
|
||||
*/
|
||||
getReference<Entity extends object>(
|
||||
entityName: EntityName<Entity>,
|
||||
id: Primary<Entity>,
|
||||
options: Omit<GetReferenceOptions, 'wrapped' | 'key'> & {
|
||||
wrapped: true;
|
||||
},
|
||||
): Ref<Entity>;
|
||||
/**
|
||||
* Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
|
||||
*/
|
||||
getReference<Entity extends object>(entityName: EntityName<Entity>, id: Primary<Entity> | Primary<Entity>[]): Entity;
|
||||
/**
|
||||
* Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
|
||||
*/
|
||||
getReference<Entity extends object>(
|
||||
entityName: EntityName<Entity>,
|
||||
id: Primary<Entity>,
|
||||
options: Omit<GetReferenceOptions, 'wrapped' | 'key'> & {
|
||||
wrapped: false;
|
||||
},
|
||||
): Entity;
|
||||
/**
|
||||
* Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
|
||||
*/
|
||||
getReference<Entity extends object>(
|
||||
entityName: EntityName<Entity>,
|
||||
id: Primary<Entity>,
|
||||
options?: GetReferenceOptions,
|
||||
): Entity | Reference<Entity>;
|
||||
/**
|
||||
* Returns total number of entities matching your `where` query.
|
||||
*/
|
||||
count<Entity extends object, Hint extends string = never>(
|
||||
entityName: EntityName<Entity>,
|
||||
where?: FilterQuery<NoInfer<Entity>>,
|
||||
options?: CountOptions<Entity, Hint>,
|
||||
): Promise<number>;
|
||||
/**
|
||||
* Tells the EntityManager to make an instance managed and persistent.
|
||||
* The entity will be entered into the database at or before transaction commit or as a result of the flush operation.
|
||||
*/
|
||||
persist<Entity extends object>(entity: Entity | Reference<Entity> | Iterable<Entity | Reference<Entity>>): this;
|
||||
/**
|
||||
* Marks entity for removal.
|
||||
* A removed entity will be removed from the database at or before transaction commit or as a result of the flush operation.
|
||||
*
|
||||
* To remove entities by condition, use `em.nativeDelete()`.
|
||||
*/
|
||||
remove<Entity extends object>(entity: Entity | Reference<Entity> | Iterable<Entity | Reference<Entity>>): this;
|
||||
/**
|
||||
* Flushes all changes to objects that have been queued up to now to the database.
|
||||
* This effectively synchronizes the in-memory state of managed objects with the database.
|
||||
*/
|
||||
flush(): Promise<void>;
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
tryFlush<Entity extends object>(
|
||||
entityName: EntityName<Entity>,
|
||||
options: {
|
||||
flushMode?: FlushMode | AnyString;
|
||||
},
|
||||
): Promise<void>;
|
||||
/**
|
||||
* Clears the EntityManager. All entities that are currently managed by this EntityManager become detached.
|
||||
*/
|
||||
clear(): void;
|
||||
/**
|
||||
* Checks whether given property can be populated on the entity.
|
||||
*/
|
||||
canPopulate<Entity extends object>(entityName: EntityName<Entity>, property: string): boolean;
|
||||
/**
|
||||
* Loads specified relations in batch. This will execute one query for each relation, that will populate it on all the specified entities.
|
||||
*/
|
||||
populate<
|
||||
Entity extends object,
|
||||
Naked extends FromEntityType<UnboxArray<Entity>> = FromEntityType<UnboxArray<Entity>>,
|
||||
Hint extends string = never,
|
||||
Fields extends string = never,
|
||||
Excludes extends string = never,
|
||||
>(
|
||||
entities: Entity,
|
||||
populate: readonly AutoPath<Naked, Hint, PopulatePath.ALL>[] | false,
|
||||
options?: EntityLoaderOptions<Naked, Fields, Excludes>,
|
||||
): Promise<
|
||||
Entity extends object[]
|
||||
? MergeLoaded<ArrayElement<Entity>, Naked, Hint, Fields, Excludes>[]
|
||||
: MergeLoaded<Entity, Naked, Hint, Fields, Excludes>
|
||||
>;
|
||||
/**
|
||||
* Returns new EntityManager instance with its own identity map
|
||||
*/
|
||||
fork(options?: ForkOptions): this;
|
||||
/**
|
||||
* Gets the UnitOfWork used by the EntityManager to coordinate operations.
|
||||
*/
|
||||
getUnitOfWork(useContext?: boolean): UnitOfWork;
|
||||
/**
|
||||
* Gets the EntityFactory used by the EntityManager.
|
||||
*/
|
||||
getEntityFactory(): EntityFactory;
|
||||
/**
|
||||
* @internal use `em.populate()` as the user facing API, this is exposed only for internal usage
|
||||
*/
|
||||
getEntityLoader(): EntityLoader;
|
||||
/**
|
||||
* Gets the Hydrator used by the EntityManager.
|
||||
*/
|
||||
getHydrator(): IHydrator;
|
||||
/**
|
||||
* Gets the EntityManager based on current transaction/request context.
|
||||
* @internal
|
||||
*/
|
||||
getContext(validate?: boolean): this;
|
||||
/** Gets the EventManager instance used by this EntityManager. */
|
||||
getEventManager(): EventManager;
|
||||
/**
|
||||
* Checks whether this EntityManager is currently operating inside a database transaction.
|
||||
*/
|
||||
isInTransaction(): boolean;
|
||||
/**
|
||||
* Gets the transaction context (driver dependent object used to make sure queries are executed on same connection).
|
||||
*/
|
||||
getTransactionContext<T extends Transaction = Transaction>(): T | undefined;
|
||||
/**
|
||||
* Sets the transaction context.
|
||||
*/
|
||||
setTransactionContext(ctx?: Transaction): void;
|
||||
/**
|
||||
* Resets the transaction context.
|
||||
*/
|
||||
resetTransactionContext(): void;
|
||||
/**
|
||||
* Gets the `MetadataStorage`.
|
||||
*/
|
||||
getMetadata(): MetadataStorage;
|
||||
/**
|
||||
* Gets the `EntityMetadata` instance when provided with the `entityName` parameter.
|
||||
*/
|
||||
getMetadata<Entity extends object>(entityName: EntityName<Entity>): EntityMetadata<Entity>;
|
||||
/**
|
||||
* Gets the EntityComparator.
|
||||
*/
|
||||
getComparator(): EntityComparator;
|
||||
private checkLockRequirements;
|
||||
private lockAndPopulate;
|
||||
private buildFields;
|
||||
/** @internal */
|
||||
preparePopulate<Entity extends object>(
|
||||
entityName: EntityName<Entity>,
|
||||
options: Pick<
|
||||
FindOptions<Entity, any, any, any>,
|
||||
'populate' | 'strategy' | 'fields' | 'flags' | 'filters' | 'exclude' | 'populateHints'
|
||||
>,
|
||||
validate?: boolean,
|
||||
): Promise<PopulateOptions<Entity>[]>;
|
||||
/**
|
||||
* when the entity is found in identity map, we check if it was partially loaded or we are trying to populate
|
||||
* some additional lazy properties, if so, we reload and merge the data from database
|
||||
*/
|
||||
protected shouldRefresh<T extends object, P extends string = never, F extends string = '*', E extends string = never>(
|
||||
meta: EntityMetadata<T>,
|
||||
entity: T,
|
||||
options: FindOneOptions<T, P, F, E>,
|
||||
): boolean;
|
||||
protected prepareOptions(
|
||||
options: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any> | CountOptions<any, any>,
|
||||
): void;
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
cacheKey<T extends object>(
|
||||
entityName: EntityName<T>,
|
||||
options: FindOptions<T, any, any, any> | FindOneOptions<T, any, any, any> | CountOptions<T, any>,
|
||||
method: string,
|
||||
where: FilterQuery<T>,
|
||||
): unknown[];
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
tryCache<T extends object, R>(
|
||||
entityName: EntityName<T>,
|
||||
config: boolean | number | [string, number] | undefined,
|
||||
key: unknown,
|
||||
refresh?: boolean,
|
||||
merge?: boolean,
|
||||
): Promise<
|
||||
| {
|
||||
data?: R | null;
|
||||
key: string;
|
||||
}
|
||||
| undefined
|
||||
>;
|
||||
/**
|
||||
* @internal
|
||||
*/
|
||||
storeCache<T>(
|
||||
config: boolean | number | [string, number] | undefined,
|
||||
key: {
|
||||
key: string;
|
||||
},
|
||||
data: T | (() => T),
|
||||
): Promise<void>;
|
||||
/**
|
||||
* Clears result cache for given cache key. If we want to be able to call this method,
|
||||
* we need to set the cache key explicitly when storing the cache.
|
||||
*
|
||||
* ```ts
|
||||
* // set the cache key to 'book-cache-key', with expiration of 60s
|
||||
* const res = await em.find(Book, { ... }, { cache: ['book-cache-key', 60_000] });
|
||||
*
|
||||
* // clear the cache key by name
|
||||
* await em.clearCache('book-cache-key');
|
||||
* ```
|
||||
*/
|
||||
clearCache(cacheKey: string): Promise<void>;
|
||||
/**
|
||||
* Returns the default schema of this EntityManager. Respects the context, so global EM will give you the contextual schema
|
||||
* if executed inside request context handler.
|
||||
*/
|
||||
get schema(): string | undefined;
|
||||
/**
|
||||
* Sets the default schema of this EntityManager. Respects the context, so global EM will set the contextual schema
|
||||
* if executed inside request context handler.
|
||||
*/
|
||||
set schema(schema: string | null | undefined);
|
||||
/** @internal */
|
||||
getDataLoader(type: 'ref' | '1:m' | 'm:n'): Promise<any>;
|
||||
/**
|
||||
* Returns the ID of this EntityManager. Respects the context, so global EM will give you the contextual ID
|
||||
* if executed inside request context handler.
|
||||
*/
|
||||
get id(): number;
|
||||
}
|
||||
export interface CreateOptions<Convert extends boolean> {
|
||||
/** creates a managed entity instance instead, bypassing the constructor call */
|
||||
managed?: boolean;
|
||||
/** create entity in a specific schema - alternatively, use `wrap(entity).setSchema()` */
|
||||
schema?: string;
|
||||
/** persist the entity automatically - this is the default behavior and is also configurable globally via `persistOnCreate` option */
|
||||
persist?: boolean;
|
||||
/** this option disables the strict typing which requires all mandatory properties to have value, it has no effect on runtime */
|
||||
partial?: boolean;
|
||||
/** convert raw database values based on mapped types (by default, already converted values are expected) */
|
||||
convertCustomTypes?: Convert;
|
||||
/**
|
||||
* Property `onCreate` hooks are normally executed during `flush` operation.
|
||||
* With this option, they will be processed early inside `em.create()` method.
|
||||
*/
|
||||
processOnCreateHooksEarly?: boolean;
|
||||
}
|
||||
export interface MergeOptions {
|
||||
refresh?: boolean;
|
||||
convertCustomTypes?: boolean;
|
||||
schema?: string;
|
||||
disableContextResolution?: boolean;
|
||||
validate?: boolean;
|
||||
cascade?: boolean /** @default true */;
|
||||
}
|
||||
export interface ForkOptions {
|
||||
/** do we want a clear identity map? defaults to true */
|
||||
clear?: boolean;
|
||||
/** use request context? should be used only for top level request scope EM, defaults to false */
|
||||
useContext?: boolean;
|
||||
/** do we want to use fresh EventManager instance? defaults to false (global instance) */
|
||||
freshEventManager?: boolean;
|
||||
/** do we want to clone current EventManager instance? defaults to false (global instance) */
|
||||
cloneEventManager?: boolean;
|
||||
/** use this flag to ignore the current async context - this is required if we want to call `em.fork()` inside the `getContext` handler */
|
||||
disableContextResolution?: boolean;
|
||||
/** set flush mode for this fork, overrides the global option can be overridden locally via FindOptions */
|
||||
flushMode?: FlushMode | `${FlushMode}`;
|
||||
/** disable transactions for this fork */
|
||||
disableTransactions?: boolean;
|
||||
/** should we keep the transaction context of the parent EM? */
|
||||
keepTransactionContext?: boolean;
|
||||
/** default schema to use for this fork */
|
||||
schema?: string;
|
||||
/** default logger context, can be overridden via {@apilink FindOptions} */
|
||||
loggerContext?: Dictionary;
|
||||
}
|
||||
Reference in New Issue
Block a user