@mikro-orm/core
Version:
TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.
82 lines (81 loc) • 4.61 kB
TypeScript
import { EntityMetadata, type AnyEntity, type EntityKey, type Constructor, type DeepPartial, type EntityName, type EntityProperty, type CleanKeys, type ExpandProperty, type IsNever, type EntityClass } from '../typings';
import type { EmbeddedOptions, EnumOptions, IndexOptions, ManyToManyOptions, ManyToOneOptions, OneToManyOptions, OneToOneOptions, PrimaryKeyOptions, PropertyOptions, SerializedPrimaryKeyOptions, UniqueOptions } from '../decorators';
import { ReferenceKind } from '../enums';
import { Type } from '../types';
type TypeType = string | NumberConstructor | StringConstructor | BooleanConstructor | DateConstructor | ArrayConstructor | Constructor<Type<any>> | Type<any>;
type TypeDef<Target> = {
type: TypeType;
} | {
entity: string | (() => string | EntityName<Target>);
};
type EmbeddedTypeDef<Target> = {
type: TypeType;
} | {
entity: string | (() => string | EntityName<Target> | EntityName<Target>[]);
};
export type EntitySchemaProperty<Target, Owner> = ({
kind: ReferenceKind.MANY_TO_ONE | 'm:1';
} & TypeDef<Target> & ManyToOneOptions<Owner, Target>) | ({
kind: ReferenceKind.ONE_TO_ONE | '1:1';
} & TypeDef<Target> & OneToOneOptions<Owner, Target>) | ({
kind: ReferenceKind.ONE_TO_MANY | '1:m';
} & TypeDef<Target> & OneToManyOptions<Owner, Target>) | ({
kind: ReferenceKind.MANY_TO_MANY | 'm:n';
} & TypeDef<Target> & ManyToManyOptions<Owner, Target>) | ({
kind: ReferenceKind.EMBEDDED | 'embedded';
} & EmbeddedTypeDef<Target> & EmbeddedOptions<Owner, Target> & PropertyOptions<Owner>) | ({
enum: true;
} & EnumOptions<Owner>) | (TypeDef<Target> & PropertyOptions<Owner>);
type OmitBaseProps<Entity, Base> = IsNever<Base> extends true ? Entity : Omit<Entity, keyof Base>;
export type EntitySchemaMetadata<Entity, Base = never> = Omit<Partial<EntityMetadata<Entity>>, 'name' | 'properties' | 'extends'> & ({
name: string;
} | {
class: EntityClass<Entity>;
name?: string;
}) & {
extends?: string | EntitySchema<Base>;
} & {
properties?: {
[Key in keyof OmitBaseProps<Entity, Base> as CleanKeys<OmitBaseProps<Entity, Base>, Key>]-?: EntitySchemaProperty<ExpandProperty<NonNullable<Entity[Key]>>, Entity>;
};
};
export declare class EntitySchema<Entity = any, Base = never> {
/**
* When schema links the entity class via `class` option, this registry allows the lookup from opposite side,
* so we can use the class in `entities` option just like the EntitySchema instance.
*/
static REGISTRY: Map<Partial<any>, EntitySchema<any, never>>;
private readonly _meta;
private internal;
private initialized;
constructor(meta: EntitySchemaMetadata<Entity, Base>);
static fromMetadata<T = AnyEntity, U = never>(meta: EntityMetadata<T> | DeepPartial<EntityMetadata<T>>): EntitySchema<T, U>;
addProperty(name: EntityKey<Entity>, type?: TypeType, options?: PropertyOptions<Entity> | EntityProperty<Entity>): void;
addEnum(name: EntityKey<Entity>, type?: TypeType, options?: EnumOptions<Entity>): void;
addVersion(name: EntityKey<Entity>, type: TypeType, options?: PropertyOptions<Entity>): void;
addPrimaryKey(name: EntityKey<Entity>, type: TypeType, options?: PrimaryKeyOptions<Entity>): void;
addSerializedPrimaryKey(name: EntityKey<Entity>, type: TypeType, options?: SerializedPrimaryKeyOptions<Entity>): void;
addEmbedded<Target = AnyEntity>(name: EntityKey<Entity>, options: EmbeddedOptions<Entity, Target>): void;
addManyToOne<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: ManyToOneOptions<Entity, Target>): void;
addManyToMany<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: ManyToManyOptions<Entity, Target>): void;
addOneToMany<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: OneToManyOptions<Entity, Target>): void;
addOneToOne<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: OneToOneOptions<Entity, Target>): void;
addIndex<Key extends string>(options: IndexOptions<Entity, Key>): void;
addUnique<Key extends string>(options: UniqueOptions<Entity, Key>): void;
setCustomRepository(repository: () => Constructor): void;
setExtends(base: string | EntitySchema): void;
setClass(proto: EntityClass<Entity>): void;
get meta(): EntityMetadata<Entity>;
get name(): EntityName<Entity>;
/**
* @internal
*/
init(): this;
private initProperties;
private initPrimaryKeys;
private normalizeType;
private createProperty;
private rename;
private renameCompositeOptions;
}
export {};