Initial commit - Event Planner application
This commit is contained in:
mberlin
326
node_modules/@mikro-orm/core/enums.d.ts
generated
vendored
Normal file
326
node_modules/@mikro-orm/core/enums.d.ts
generated
vendored
Normal file
@@ -0,0 +1,326 @@
|
||||
import type { EntityKey, ExpandProperty } from './typings.js';
|
||||
import type { Transaction } from './connections/Connection.js';
|
||||
import type { LogContext } from './logging/Logger.js';
|
||||
/** Controls when the `EntityManager` flushes pending changes to the database. */
|
||||
export declare enum FlushMode {
|
||||
/** The `EntityManager` delays the flush until the current Transaction is committed. */
|
||||
COMMIT = 'commit',
|
||||
/** This is the default mode, and it flushes the `EntityManager` only if necessary. */
|
||||
AUTO = 'auto',
|
||||
/** Flushes the `EntityManager` before every query. */
|
||||
ALWAYS = 'always',
|
||||
}
|
||||
/** Controls how populate hints are resolved when using `FindOptions.populateWhere`. */
|
||||
export declare enum PopulateHint {
|
||||
/** Infer population hints from the `where` condition. */
|
||||
INFER = 'infer',
|
||||
/** Apply population hints to all relations. */
|
||||
ALL = 'all',
|
||||
}
|
||||
/** Special tokens used as populate path values in `FindOptions.populate`. */
|
||||
export declare enum PopulatePath {
|
||||
/** Infer which relations to populate based on fields accessed in the `where` or `orderBy` clause. */
|
||||
INFER = '$infer',
|
||||
/** Populate all relations. */
|
||||
ALL = '*',
|
||||
}
|
||||
/** Logical grouping operators for combining query conditions. */
|
||||
export declare enum GroupOperator {
|
||||
/** Logical AND — all conditions must match. */
|
||||
$and = 'and',
|
||||
/** Logical OR — at least one condition must match. */
|
||||
$or = 'or',
|
||||
}
|
||||
/** Comparison and filtering operators used in query conditions. */
|
||||
export declare enum QueryOperator {
|
||||
/** Equal. */
|
||||
$eq = '=',
|
||||
/** Included in the given list. */
|
||||
$in = 'in',
|
||||
/** Not included in the given list. */
|
||||
$nin = 'not in',
|
||||
/** Greater than. */
|
||||
$gt = '>',
|
||||
/** Greater than or equal to. */
|
||||
$gte = '>=',
|
||||
/** Less than. */
|
||||
$lt = '<',
|
||||
/** Less than or equal to. */
|
||||
$lte = '<=',
|
||||
/** Not equal. */
|
||||
$ne = '!=',
|
||||
/** Negation wrapper. */
|
||||
$not = 'not',
|
||||
/** SQL LIKE pattern matching. */
|
||||
$like = 'like',
|
||||
/** Regular expression matching. */
|
||||
$re = 'regexp',
|
||||
/** Full-text search. */
|
||||
$fulltext = 'fulltext',
|
||||
/** Checks that the value is not null (i.e., exists). */
|
||||
$exists = 'not null',
|
||||
/** Case-insensitive LIKE (PostgreSQL only). */
|
||||
$ilike = 'ilike', // postgres only
|
||||
/** Array overlap operator (PostgreSQL only). */
|
||||
$overlap = '&&', // postgres only
|
||||
/** Array/JSON contains operator (PostgreSQL only). */
|
||||
$contains = '@>', // postgres only
|
||||
/** Array/JSON contained-by operator (PostgreSQL only). */
|
||||
$contained = '<@', // postgres only
|
||||
/** No element in the collection matches (SQL only). */
|
||||
$none = 'none', // collection operators, sql only
|
||||
/** At least one element in the collection matches (SQL only). */
|
||||
$some = 'some', // collection operators, sql only
|
||||
/** Every element in the collection matches (SQL only). */
|
||||
$every = 'every', // collection operators, sql only
|
||||
/** Matches collections by their size (SQL only). */
|
||||
$size = 'size', // collection operators, sql only
|
||||
/** JSON object has the given key (PostgreSQL only). */
|
||||
$hasKey = '?', // postgres only, json
|
||||
/** JSON object has all of the given keys (PostgreSQL only). */
|
||||
$hasKeys = '?&', // postgres only, json
|
||||
/** JSON object has at least one of the given keys (PostgreSQL only). */
|
||||
$hasSomeKeys = '?|', // postgres only, json
|
||||
/** Matches an element inside a JSON array (SQL only). */
|
||||
$elemMatch = 'elemMatch',
|
||||
}
|
||||
export declare const ARRAY_OPERATORS: string[];
|
||||
export declare const JSON_KEY_OPERATORS: string[];
|
||||
/** Sort direction for query results. Both upper- and lower-case variants are accepted. */
|
||||
export declare enum QueryOrder {
|
||||
/** Ascending order. */
|
||||
ASC = 'ASC',
|
||||
/** Ascending order with nulls sorted last. */
|
||||
ASC_NULLS_LAST = 'ASC NULLS LAST',
|
||||
/** Ascending order with nulls sorted first. */
|
||||
ASC_NULLS_FIRST = 'ASC NULLS FIRST',
|
||||
/** Descending order. */
|
||||
DESC = 'DESC',
|
||||
/** Descending order with nulls sorted last. */
|
||||
DESC_NULLS_LAST = 'DESC NULLS LAST',
|
||||
/** Descending order with nulls sorted first. */
|
||||
DESC_NULLS_FIRST = 'DESC NULLS FIRST',
|
||||
/** Ascending order (lower-case variant). */
|
||||
asc = 'asc',
|
||||
/** Ascending order with nulls sorted last (lower-case variant). */
|
||||
asc_nulls_last = 'asc nulls last',
|
||||
/** Ascending order with nulls sorted first (lower-case variant). */
|
||||
asc_nulls_first = 'asc nulls first',
|
||||
/** Descending order (lower-case variant). */
|
||||
desc = 'desc',
|
||||
/** Descending order with nulls sorted last (lower-case variant). */
|
||||
desc_nulls_last = 'desc nulls last',
|
||||
/** Descending order with nulls sorted first (lower-case variant). */
|
||||
desc_nulls_first = 'desc nulls first',
|
||||
}
|
||||
/** Numeric sort direction, compatible with MongoDB-style ordering. */
|
||||
export declare enum QueryOrderNumeric {
|
||||
/** Ascending order. */
|
||||
ASC = 1,
|
||||
/** Descending order. */
|
||||
DESC = -1,
|
||||
}
|
||||
export type QueryOrderKeysFlat = QueryOrder | QueryOrderNumeric | `${QueryOrder}`;
|
||||
export type QueryOrderKeys<T> = QueryOrderKeysFlat | QueryOrderMap<T>;
|
||||
export type QueryOrderMap<T> = {
|
||||
[K in EntityKey<T>]?: QueryOrderKeys<ExpandProperty<T[K]>>;
|
||||
};
|
||||
export interface FlatQueryOrderMap {
|
||||
[x: string]: QueryOrderKeysFlat;
|
||||
}
|
||||
/** Flags that modify query builder behavior. */
|
||||
export declare enum QueryFlag {
|
||||
/** Add a DISTINCT clause to the SELECT statement. */
|
||||
DISTINCT = 'DISTINCT',
|
||||
/** Enable result pagination via a sub-query for the primary keys. */
|
||||
PAGINATE = 'PAGINATE',
|
||||
/** Disable the automatic pagination sub-query. */
|
||||
DISABLE_PAGINATE = 'DISABLE_PAGINATE',
|
||||
/** Wrap UPDATE statements in a sub-query. */
|
||||
UPDATE_SUB_QUERY = 'UPDATE_SUB_QUERY',
|
||||
/** Wrap DELETE statements in a sub-query. */
|
||||
DELETE_SUB_QUERY = 'DELETE_SUB_QUERY',
|
||||
/** Convert values through custom type mappings when reading results. */
|
||||
CONVERT_CUSTOM_TYPES = 'CONVERT_CUSTOM_TYPES',
|
||||
/** Include lazy formula properties in the SELECT clause. */
|
||||
INCLUDE_LAZY_FORMULAS = 'INCLUDE_LAZY_FORMULAS',
|
||||
/** Automatically join the owning side of one-to-one relations. */
|
||||
AUTO_JOIN_ONE_TO_ONE_OWNER = 'AUTO_JOIN_ONE_TO_ONE_OWNER',
|
||||
/** Infer the populate hint from the query fields. */
|
||||
INFER_POPULATE = 'INFER_POPULATE',
|
||||
/** Prevent nested conditions from being promoted to INNER JOINs. */
|
||||
DISABLE_NESTED_INNER_JOIN = 'DISABLE_NESTED_INNER_JOIN',
|
||||
/** Enable IDENTITY_INSERT for explicit PK values (MSSQL only). */
|
||||
IDENTITY_INSERT = 'IDENTITY_INSERT', // mssql only
|
||||
/** Use an OUTPUT...INTO temp table for returning rows (MSSQL only). */
|
||||
OUTPUT_TABLE = 'OUTPUT_TABLE',
|
||||
}
|
||||
export declare const SCALAR_TYPES: Set<string>;
|
||||
/** Describes the kind of relationship a property represents. */
|
||||
export declare enum ReferenceKind {
|
||||
/** A plain scalar property (not a relation). */
|
||||
SCALAR = 'scalar',
|
||||
/** A one-to-one relation. */
|
||||
ONE_TO_ONE = '1:1',
|
||||
/** A one-to-many relation (inverse side of a many-to-one). */
|
||||
ONE_TO_MANY = '1:m',
|
||||
/** A many-to-one relation (owning side). */
|
||||
MANY_TO_ONE = 'm:1',
|
||||
/** A many-to-many relation. */
|
||||
MANY_TO_MANY = 'm:n',
|
||||
/** An embedded entity (inline object stored within the parent). */
|
||||
EMBEDDED = 'embedded',
|
||||
}
|
||||
/** Cascade operations that propagate from a parent entity to its relations. */
|
||||
export declare enum Cascade {
|
||||
/** Cascade persist — new related entities are automatically persisted. */
|
||||
PERSIST = 'persist',
|
||||
/** Cascade merge — detached related entities are merged into the identity map. */
|
||||
MERGE = 'merge',
|
||||
/** Cascade remove — removing the parent also removes related entities. */
|
||||
REMOVE = 'remove',
|
||||
/** Enable all cascade operations (persist, merge, remove). */
|
||||
ALL = 'all',
|
||||
/** @internal */
|
||||
SCHEDULE_ORPHAN_REMOVAL = 'schedule_orphan_removal',
|
||||
/** @internal */
|
||||
CANCEL_ORPHAN_REMOVAL = 'cancel_orphan_removal',
|
||||
}
|
||||
/** Strategy used to load related entities when populating. */
|
||||
export declare enum LoadStrategy {
|
||||
/** Load relations with a separate SELECT ... WHERE pk IN (...) query. */
|
||||
SELECT_IN = 'select-in',
|
||||
/** Load relations via SQL JOINs in a single query. */
|
||||
JOINED = 'joined',
|
||||
/** Use joined strategy for to-one relations and select-in for to-many. */
|
||||
BALANCED = 'balanced',
|
||||
}
|
||||
/** Controls which relation types use the dataloader for batched loading. */
|
||||
export declare enum DataloaderType {
|
||||
/** Dataloader is disabled. */
|
||||
NONE = 0,
|
||||
/** Use the dataloader for Reference (to-one) relations only. */
|
||||
REFERENCE = 1,
|
||||
/** Use the dataloader for Collection (to-many) relations only. */
|
||||
COLLECTION = 2,
|
||||
/** Use the dataloader for both Reference and Collection relations. */
|
||||
ALL = 3,
|
||||
}
|
||||
/** Locking strategy for concurrency control. */
|
||||
export declare enum LockMode {
|
||||
/** No locking. */
|
||||
NONE = 0,
|
||||
/** Optimistic locking via a version column. */
|
||||
OPTIMISTIC = 1,
|
||||
/** Pessimistic shared lock (FOR SHARE). */
|
||||
PESSIMISTIC_READ = 2,
|
||||
/** Pessimistic exclusive lock (FOR UPDATE). */
|
||||
PESSIMISTIC_WRITE = 3,
|
||||
/** Pessimistic exclusive lock that skips already-locked rows (FOR UPDATE SKIP LOCKED). */
|
||||
PESSIMISTIC_PARTIAL_WRITE = 4,
|
||||
/** Pessimistic exclusive lock that fails immediately if the row is locked (FOR UPDATE NOWAIT). */
|
||||
PESSIMISTIC_WRITE_OR_FAIL = 5,
|
||||
/** Pessimistic shared lock that skips already-locked rows (FOR SHARE SKIP LOCKED). */
|
||||
PESSIMISTIC_PARTIAL_READ = 6,
|
||||
/** Pessimistic shared lock that fails immediately if the row is locked (FOR SHARE NOWAIT). */
|
||||
PESSIMISTIC_READ_OR_FAIL = 7,
|
||||
}
|
||||
/** Transaction isolation levels as defined by the SQL standard (plus vendor extensions). */
|
||||
export declare enum IsolationLevel {
|
||||
/** Allows dirty reads, non-repeatable reads, and phantom reads. */
|
||||
READ_UNCOMMITTED = 'read uncommitted',
|
||||
/** Prevents dirty reads; non-repeatable and phantom reads are still possible. */
|
||||
READ_COMMITTED = 'read committed',
|
||||
/** Snapshot isolation — each transaction sees a consistent snapshot of the database (MSSQL). */
|
||||
SNAPSHOT = 'snapshot',
|
||||
/** Prevents dirty and non-repeatable reads; phantom reads are still possible. */
|
||||
REPEATABLE_READ = 'repeatable read',
|
||||
/** Full isolation — transactions are executed as if they were run sequentially. */
|
||||
SERIALIZABLE = 'serializable',
|
||||
}
|
||||
/** Lifecycle and transaction events emitted by the ORM. */
|
||||
export declare enum EventType {
|
||||
/** Fired when an entity instance is created (via constructor or `em.create`). */
|
||||
onInit = 'onInit',
|
||||
/** Fired after an entity is loaded from the database. */
|
||||
onLoad = 'onLoad',
|
||||
/** Fired before a new entity is inserted into the database. */
|
||||
beforeCreate = 'beforeCreate',
|
||||
/** Fired after a new entity has been inserted into the database. */
|
||||
afterCreate = 'afterCreate',
|
||||
/** Fired before an existing entity is updated in the database. */
|
||||
beforeUpdate = 'beforeUpdate',
|
||||
/** Fired after an existing entity has been updated in the database. */
|
||||
afterUpdate = 'afterUpdate',
|
||||
/** Fired before an upsert operation. */
|
||||
beforeUpsert = 'beforeUpsert',
|
||||
/** Fired after an upsert operation. */
|
||||
afterUpsert = 'afterUpsert',
|
||||
/** Fired before an entity is deleted from the database. */
|
||||
beforeDelete = 'beforeDelete',
|
||||
/** Fired after an entity has been deleted from the database. */
|
||||
afterDelete = 'afterDelete',
|
||||
/** Fired at the very beginning of `em.flush()`, before change detection. */
|
||||
beforeFlush = 'beforeFlush',
|
||||
/** Fired during `em.flush()` after change detection but before database writes. */
|
||||
onFlush = 'onFlush',
|
||||
/** Fired after `em.flush()` has completed all database writes. */
|
||||
afterFlush = 'afterFlush',
|
||||
/** Fired before a new database transaction is started. */
|
||||
beforeTransactionStart = 'beforeTransactionStart',
|
||||
/** Fired after a new database transaction has been started. */
|
||||
afterTransactionStart = 'afterTransactionStart',
|
||||
/** Fired before a database transaction is committed. */
|
||||
beforeTransactionCommit = 'beforeTransactionCommit',
|
||||
/** Fired after a database transaction has been committed. */
|
||||
afterTransactionCommit = 'afterTransactionCommit',
|
||||
/** Fired before a database transaction is rolled back. */
|
||||
beforeTransactionRollback = 'beforeTransactionRollback',
|
||||
/** Fired after a database transaction has been rolled back. */
|
||||
afterTransactionRollback = 'afterTransactionRollback',
|
||||
}
|
||||
export declare const EventTypeMap: Record<EventType, number>;
|
||||
export type TransactionEventType =
|
||||
| EventType.beforeTransactionStart
|
||||
| EventType.afterTransactionStart
|
||||
| EventType.beforeTransactionCommit
|
||||
| EventType.afterTransactionCommit
|
||||
| EventType.beforeTransactionRollback
|
||||
| EventType.afterTransactionRollback;
|
||||
/** Controls how a transactional operation interacts with an existing transaction. */
|
||||
export declare enum TransactionPropagation {
|
||||
/** Join the current transaction or create a new one if none exists. */
|
||||
REQUIRED = 'required',
|
||||
/** Always create a new transaction, suspending the current one if it exists. */
|
||||
REQUIRES_NEW = 'requires_new',
|
||||
/** Create a nested savepoint within the current transaction, or a new transaction if none exists. */
|
||||
NESTED = 'nested',
|
||||
/** Execute non-transactionally, suspending the current transaction if one exists. */
|
||||
NOT_SUPPORTED = 'not_supported',
|
||||
/** Join the current transaction if one exists, otherwise execute non-transactionally. */
|
||||
SUPPORTS = 'supports',
|
||||
/** Join the current transaction; throw if no transaction is active. */
|
||||
MANDATORY = 'mandatory',
|
||||
/** Execute non-transactionally; throw if a transaction is active. */
|
||||
NEVER = 'never',
|
||||
}
|
||||
export interface TransactionOptions {
|
||||
ctx?: Transaction;
|
||||
propagation?: TransactionPropagation | `${TransactionPropagation}`;
|
||||
isolationLevel?: IsolationLevel | `${IsolationLevel}`;
|
||||
readOnly?: boolean;
|
||||
clear?: boolean;
|
||||
flushMode?: FlushMode | `${FlushMode}`;
|
||||
ignoreNestedTransactions?: boolean;
|
||||
loggerContext?: LogContext;
|
||||
}
|
||||
export declare abstract class PlainObject {}
|
||||
/** Constraint deferral mode for database constraints (e.g., foreign keys, unique). */
|
||||
export declare enum DeferMode {
|
||||
/** The constraint is checked immediately by default, but can be deferred within a transaction. */
|
||||
INITIALLY_IMMEDIATE = 'immediate',
|
||||
/** The constraint is deferred until the transaction is committed. */
|
||||
INITIALLY_DEFERRED = 'deferred',
|
||||
}
|
||||
/** With `absolute` the prefix is set at the root of the entity (regardless of the nesting level) */
|
||||
export type EmbeddedPrefixMode = 'absolute' | 'relative';
|
||||
Reference in New Issue
Block a user