@mikro-orm/core 6.3.8-dev.0 → 6.3.8-dev.1

package/decorators/ManyToMany.d.ts

@@ -3,21 +3,38 @@ import type { EntityName, AnyEntity, FilterQuery, AnyString } from '../typings';
 import { type QueryOrderMap } from '../enums';
 export declare function ManyToMany<T extends object, O>(entity?: ManyToManyOptions<T, O> | string | (() => EntityName<T>), mappedBy?: (string & keyof T) | ((e: T) => any), options?: Partial<ManyToManyOptions<T, O>>): (target: AnyEntity, propertyName: string) => any;
 export interface ManyToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
+    /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner?: boolean;
+    /** Point to the inverse side property name. */
     inversedBy?: (string & keyof Target) | ((e: Target) => any);
+    /** Point to the owning side property name. */
     mappedBy?: (string & keyof Target) | ((e: Target) => any);
+    /** Condition for {@doclink collections#declarative-partial-loading | Declarative partial loading}. */
     where?: FilterQuery<Target>;
+    /** Set default ordering. */
     orderBy?: QueryOrderMap<Target> | QueryOrderMap<Target>[];
+    /** Force stable insertion order of items in the collection (see {@doclink collections | Collections}). */
     fixedOrder?: boolean;
+    /** Override default order column name (`id`) for fixed ordering. */
     fixedOrderColumn?: string;
+    /** Override default name for pivot table (see {@doclink naming-strategy | Naming Strategy}). */
     pivotTable?: string;
+    /** Set pivot entity for this relation (see {@doclink collections#custom-pivot-table-entity | Custom pivot table entity}). */
     pivotEntity?: string | (() => EntityName<any>);
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
     joinColumn?: string;
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
     joinColumns?: string[];
+    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
     inverseJoinColumn?: string;
+    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
     inverseJoinColumns?: string[];
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
     referenceColumnName?: string;
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
     referencedColumnNames?: string[];
+    /** What to do when the target entity gets deleted. */
     deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
+    /** What to do when the reference to the target entity gets updated. */
     updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
 }

package/decorators/ManyToOne.d.ts

@@ -3,15 +3,26 @@ import { type DeferMode } from '../enums';
 import type { AnyEntity, AnyString, EntityName } from '../typings';
 export declare function ManyToOne<T extends object, O>(entity?: ManyToOneOptions<T, O> | string | ((e?: any) => EntityName<T>), options?: Partial<ManyToOneOptions<T, O>>): (target: AnyEntity, propertyName: string) => any;
 export interface ManyToOneOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
+    /** Point to the inverse side property name. */
     inversedBy?: (string & keyof Target) | ((e: Target) => any);
+    /** Wrap the entity in {@apilink Reference} wrapper. */
     ref?: boolean;
+    /** Use this relation as a primary key. */
     primary?: boolean;
+    /** Map this relation to the primary key value instead of an entity. */
     mapToPk?: boolean;
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
     joinColumn?: string;
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
     joinColumns?: string[];
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
     referenceColumnName?: string;
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
     referencedColumnNames?: string[];
+    /** What to do when the target entity gets deleted. */
     deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
+    /** What to do when the reference to the target entity gets updated. */
     updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
+    /** Set the constraint type. Immediate constraints are checked for each statement, while deferred ones are only checked at the end of the transaction. Only for postgres unique constraints. */
     deferMode?: DeferMode | `${DeferMode}`;
 }

package/decorators/OneToMany.d.ts

@@ -4,15 +4,25 @@ import type { EntityName, AnyEntity, FilterQuery } from '../typings';
 export declare function createOneToDecorator<Target, Owner>(entity: OneToManyOptions<Owner, Target> | string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any) | undefined, options: Partial<OneToManyOptions<Owner, Target>>, kind: ReferenceKind): (target: AnyEntity, propertyName: string) => any;
 export declare function OneToMany<Target, Owner>(entity: string | ((e?: any) => EntityName<Target>), mappedBy: (string & keyof Target) | ((e: Target) => any), options?: Partial<OneToManyOptions<Owner, Target>>): (target: AnyEntity, propertyName: string) => void;
 export declare function OneToMany<Target, Owner>(options: OneToManyOptions<Owner, Target>): (target: AnyEntity, propertyName: string) => void;
-export type OneToManyOptions<Owner, Target> = ReferenceOptions<Owner, Target> & {
-    entity?: string | (() => EntityName<Target>);
+export interface OneToManyOptions<Owner, Target> extends ReferenceOptions<Owner, Target> {
+    /** Remove the entity when it gets disconnected from the relationship (see {@doclink cascading | Cascading}). */
     orphanRemoval?: boolean;
+    /** Set default ordering. */
     orderBy?: QueryOrderMap<Target> | QueryOrderMap<Target>[];
+    /** Condition for {@doclink collections#declarative-partial-loading | Declarative partial loading}. */
     where?: FilterQuery<Target>;
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
     joinColumn?: string;
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
     joinColumns?: string[];
+    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
     inverseJoinColumn?: string;
+    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
     inverseJoinColumns?: string[];
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
     referenceColumnName?: string;
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    referencedColumnNames?: string[];
+    /** Point to the owning side property name. */
     mappedBy: (string & keyof Target) | ((e: Target) => any);
-};
+}

package/decorators/OneToOne.d.ts

@@ -3,12 +3,20 @@ import { type OneToManyOptions } from './OneToMany';
 import type { AnyString, EntityName } from '../typings';
 export declare function OneToOne<Target, Owner>(entity?: OneToOneOptions<Owner, Target> | string | ((e: Owner) => EntityName<Target>), mappedByOrOptions?: (string & keyof Target) | ((e: Target) => any) | Partial<OneToOneOptions<Owner, Target>>, options?: Partial<OneToOneOptions<Owner, Target>>): (target: import("../typings").AnyEntity, propertyName: string) => any;
 export interface OneToOneOptions<Owner, Target> extends Partial<Omit<OneToManyOptions<Owner, Target>, 'orderBy'>> {
+    /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
     owner?: boolean;
+    /** Point to the inverse side property name. */
     inversedBy?: (string & keyof Target) | ((e: Target) => any);
+    /** Wrap the entity in {@apilink Reference} wrapper. */
     ref?: boolean;
+    /** Use this relation as a primary key. */
     primary?: boolean;
+    /** Map this relation to the primary key value instead of an entity. */
     mapToPk?: boolean;
+    /** What to do when the target entity gets deleted. */
     deleteRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
+    /** What to do when the reference to the target entity gets updated. */
     updateRule?: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString;
+    /** Set the constraint type. Immediate constraints are checked for each statement, while deferred ones are only checked at the end of the transaction. Only for postgres unique constraints. */
     deferMode?: DeferMode | `${DeferMode}`;
 }

package/decorators/Property.d.ts

@@ -3,7 +3,7 @@ import type { EntityName, Constructor, CheckCallback, GeneratedColumnCallback, A
 import type { Type, types } from '../types';
 import type { EntityManager } from '../EntityManager';
 export declare function Property<T extends object>(options?: PropertyOptions<T>): (target: any, propertyName: string) => any;
-export type PropertyOptions<Owner> = {
+export interface PropertyOptions<Owner> {
     /**
      * Alias for `fieldName`.
      */
@@ -214,12 +214,16 @@ export type PropertyOptions<Owner> = {
      * @see https://mikro-orm.io/docs/defining-entities#sql-generated-columns
      */
     ignoreSchemaChanges?: ('type' | 'extra' | 'default')[];
-};
+}
 export interface ReferenceOptions<Owner, Target> extends PropertyOptions<Owner> {
+    /** Set target entity type. */
     entity?: string | (() => EntityName<Target>);
+    /** Set what actions on owning entity should be cascaded to the relationship. Defaults to [Cascade.PERSIST, Cascade.MERGE] (see {@doclink cascading}). */
     cascade?: Cascade[];
+    /** Always load the relationship. Discouraged for use with to-many relations for performance reasons. */
     eager?: boolean;
-    strategy?: LoadStrategy;
+    /** Override the default loading strategy for this property. This option has precedence over the global `loadStrategy`, but can be overridden by `FindOptions.strategy`. */
+    strategy?: LoadStrategy | `${LoadStrategy}`;
 }
 /**
  * Inspired by https://github.com/typeorm/typeorm/blob/941b584ba135617e55d6685caef671172ec1dc03/src/driver/types/ColumnTypes.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.3.8-dev.0",
+  "version": "6.3.8-dev.1",
   "description": "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.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.2.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.3.8-dev.0",
+    "mikro-orm": "6.3.8-dev.1",
     "reflect-metadata": "0.2.2"
   }
 }