144 lines
4.3 KiB
TypeScript
144 lines
4.3 KiB
TypeScript
import type { EntityManagerType, IDatabaseDriver } from './drivers/IDatabaseDriver.js';
|
|
import { type EntitySchema } from './metadata/EntitySchema.js';
|
|
import { MetadataStorage } from './metadata/MetadataStorage.js';
|
|
import { Configuration, type Options } from './utils/Configuration.js';
|
|
import type { EntityManager } from './EntityManager.js';
|
|
import type {
|
|
AnyEntity,
|
|
Constructor,
|
|
EntityClass,
|
|
EntityMetadata,
|
|
EntityName,
|
|
IEntityGenerator,
|
|
IMigrator,
|
|
ISeedManager,
|
|
} from './typings.js';
|
|
/** @internal */
|
|
export declare function loadOptionalDependencies(options: Partial<Options>): Promise<void>;
|
|
/**
|
|
* The main class used to configure and bootstrap the ORM.
|
|
*
|
|
* @example
|
|
* ```ts
|
|
* // import from driver package
|
|
* import { MikroORM, defineEntity, p } from '@mikro-orm/sqlite';
|
|
*
|
|
* const User = defineEntity({
|
|
* name: 'User',
|
|
* properties: {
|
|
* id: p.integer().primary(),
|
|
* name: p.string(),
|
|
* },
|
|
* });
|
|
*
|
|
* const orm = new MikroORM({
|
|
* entities: [User],
|
|
* dbName: 'my.db',
|
|
* });
|
|
* await orm.schema.update();
|
|
*
|
|
* const em = orm.em.fork();
|
|
* const u1 = em.create(User, { name: 'John' });
|
|
* const u2 = em.create(User, { name: 'Ben' });
|
|
* await em.flush();
|
|
* ```
|
|
*/
|
|
export declare class MikroORM<
|
|
Driver extends IDatabaseDriver = IDatabaseDriver,
|
|
EM extends Driver[typeof EntityManagerType] & EntityManager<Driver> = Driver[typeof EntityManagerType] &
|
|
EntityManager<Driver>,
|
|
Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (
|
|
| string
|
|
| EntityClass<AnyEntity>
|
|
| EntitySchema
|
|
)[],
|
|
> {
|
|
#private;
|
|
/** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
|
|
em: EM & {
|
|
'~entities'?: Entities;
|
|
};
|
|
/** The database driver instance used by this ORM. */
|
|
readonly driver: Driver;
|
|
/** The ORM configuration instance. */
|
|
readonly config: Configuration<Driver>;
|
|
/**
|
|
* Initialize the ORM, load entity metadata, create EntityManager and connect to the database.
|
|
* If you omit the `options` parameter, your CLI config will be used.
|
|
*/
|
|
static init<
|
|
D extends IDatabaseDriver = IDatabaseDriver,
|
|
EM extends D[typeof EntityManagerType] & EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>,
|
|
Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (
|
|
| string
|
|
| EntityClass<AnyEntity>
|
|
| EntitySchema
|
|
)[],
|
|
>(options: Partial<Options<D, EM, Entities>>): Promise<MikroORM<D, EM, Entities>>;
|
|
/**
|
|
* Synchronous variant of the `init` method with some limitations:
|
|
* - folder-based discovery not supported
|
|
* - ORM extensions are not autoloaded
|
|
* - when metadata cache is enabled, `FileCacheAdapter` needs to be explicitly set in the config
|
|
*/
|
|
constructor(options: Partial<Options<Driver, EM, Entities>>);
|
|
/**
|
|
* Connects to the database.
|
|
*/
|
|
connect(): Promise<Driver>;
|
|
/**
|
|
* Reconnects, possibly to a different database.
|
|
*/
|
|
reconnect(options?: Partial<Options<Driver, EM, Entities>>): Promise<void>;
|
|
/**
|
|
* Checks whether the database connection is active.
|
|
*/
|
|
isConnected(): Promise<boolean>;
|
|
/**
|
|
* Checks whether the database connection is active, returns the reason if not.
|
|
*/
|
|
checkConnection(): Promise<
|
|
| {
|
|
ok: true;
|
|
}
|
|
| {
|
|
ok: false;
|
|
reason: string;
|
|
error?: Error;
|
|
}
|
|
>;
|
|
/**
|
|
* Closes the database connection.
|
|
*/
|
|
close(force?: boolean): Promise<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>;
|
|
private createEntityManager;
|
|
/**
|
|
* Allows dynamically discovering new entity by reference, handy for testing schema diffing.
|
|
*/
|
|
discoverEntity<T extends Constructor | EntitySchema>(entities: T | T[], reset?: EntityName | EntityName[]): void;
|
|
/**
|
|
* Gets the SchemaGenerator.
|
|
*/
|
|
get schema(): ReturnType<ReturnType<Driver['getPlatform']>['getSchemaGenerator']>;
|
|
/**
|
|
* Gets the SeedManager
|
|
*/
|
|
get seeder(): ISeedManager;
|
|
/**
|
|
* Gets the Migrator.
|
|
*/
|
|
get migrator(): IMigrator;
|
|
/**
|
|
* Gets the EntityGenerator.
|
|
*/
|
|
get entityGenerator(): IEntityGenerator;
|
|
}
|