@mikro-orm/core 7.0.2-dev.9 → 7.0.2

package/drivers/IDatabaseDriver.js

@@ -1 +1,2 @@
+/** Symbol used to extract the EntityManager type from a driver instance. */
 export const EntityManagerType = Symbol('EntityManagerType');

package/entity/BaseEntity.d.ts

@@ -1,81 +1,129 @@
 import { type Ref } from './Reference.js';
-import type { AutoPath, EntityData, EntityDTO, Loaded, LoadedReference, AddEager, EntityKey, FromEntityType, IsSubset, MergeSelected, SerializeDTO } from '../typings.js';
+import type {
+  AutoPath,
+  EntityData,
+  EntityDTO,
+  Loaded,
+  LoadedReference,
+  AddEager,
+  EntityKey,
+  FromEntityType,
+  IsSubset,
+  MergeSelected,
+  SerializeDTO,
+} from '../typings.js';
 import { type AssignOptions } from './EntityAssigner.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
 import { type SerializeOptions } from '../serialization/EntitySerializer.js';
 import type { FindOneOptions } from '../drivers/IDatabaseDriver.js';
 import type { PopulatePath } from '../enums.js';
+/** Base class for entities providing convenience methods like `assign()`, `toObject()`, and `populate()`. */
 export declare abstract class BaseEntity {
-    isInitialized(): boolean;
-    populated(populated?: boolean): void;
-    populate<Entity extends this = this, Hint extends string = never, Fields extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity, Fields>): Promise<Loaded<Entity, Hint>>;
-    toReference<Entity extends this = this>(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
-    /**
-     * Converts the entity to a plain object representation.
-     *
-     * **Note on typing with `Loaded` entities:** When called on a `Loaded<Entity, 'relation'>` type,
-     * the return type will be `EntityDTO<Entity>` (with relations as primary keys), not
-     * `EntityDTO<Loaded<Entity, 'relation'>>` (with loaded relations as nested objects).
-     * This is a TypeScript limitation - the `this` type resolves to the class, not the `Loaded` wrapper.
-     *
-     * For correct typing that reflects loaded relations, use `wrap()`:
-     * ```ts
-     * const result = await em.find(User, {}, { populate: ['profile'] });
-     * // Type: EntityDTO<User> (profile is number)
-     * const obj1 = result[0].toObject();
-     * // Type: EntityDTO<Loaded<User, 'profile'>> (profile is nested object)
-     * const obj2 = wrap(result[0]).toObject();
-     * ```
-     *
-     * Runtime values are correct in both cases - only the static types differ.
-     */
-    toObject<Entity extends this = this>(): EntityDTO<Entity>;
-    /**
-     * Converts the entity to a plain object representation.
-     *
-     * **Note on typing with `Loaded` entities:** When called on a `Loaded<Entity, 'relation'>` type,
-     * the return type will be `EntityDTO<Entity>` (with relations as primary keys), not
-     * `EntityDTO<Loaded<Entity, 'relation'>>` (with loaded relations as nested objects).
-     * This is a TypeScript limitation - the `this` type resolves to the class, not the `Loaded` wrapper.
-     *
-     * For correct typing that reflects loaded relations, use `wrap()`:
-     * ```ts
-     * const result = await em.find(User, {}, { populate: ['profile'] });
-     * // Type: EntityDTO<User> (profile is number)
-     * const obj1 = result[0].toObject();
-     * // Type: EntityDTO<Loaded<User, 'profile'>> (profile is nested object)
-     * const obj2 = wrap(result[0]).toObject();
-     * ```
-     *
-     * Runtime values are correct in both cases - only the static types differ.
-     */
-    toObject<Entity extends this = this>(ignoreFields: never[]): EntityDTO<Entity>;
-    /**
-     * Converts the entity to a plain object representation.
-     *
-     * **Note on typing with `Loaded` entities:** When called on a `Loaded<Entity, 'relation'>` type,
-     * the return type will be `EntityDTO<Entity>` (with relations as primary keys), not
-     * `EntityDTO<Loaded<Entity, 'relation'>>` (with loaded relations as nested objects).
-     * This is a TypeScript limitation - the `this` type resolves to the class, not the `Loaded` wrapper.
-     *
-     * For correct typing that reflects loaded relations, use `wrap()`:
-     * ```ts
-     * const result = await em.find(User, {}, { populate: ['profile'] });
-     * // Type: EntityDTO<User> (profile is number)
-     * const obj1 = result[0].toObject();
-     * // Type: EntityDTO<Loaded<User, 'profile'>> (profile is nested object)
-     * const obj2 = wrap(result[0]).toObject();
-     * ```
-     *
-     * Runtime values are correct in both cases - only the static types differ.
-     *
-     * @param ignoreFields - Array of field names to omit from the result.
-     */
-    toObject<Entity extends this = this, Ignored extends EntityKey<Entity> = never>(ignoreFields: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
-    toPOJO<Entity extends this = this>(): EntityDTO<Entity>;
-    serialize<Entity extends this = this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): SerializeDTO<Naked, Hint, Exclude>;
-    assign<Entity extends this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
-    init<Entity extends this = this, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
-    getSchema(): string | undefined;
-    setSchema(schema?: string): void;
+  /** Returns whether the entity has been fully loaded from the database. */
+  isInitialized(): boolean;
+  /** Marks the entity as populated or not for serialization purposes. */
+  populated(populated?: boolean): void;
+  /** Loads the specified relations on this entity. */
+  populate<Entity extends this = this, Hint extends string = never, Fields extends string = never>(
+    populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false,
+    options?: EntityLoaderOptions<Entity, Fields>,
+  ): Promise<Loaded<Entity, Hint>>;
+  /** Returns a Reference wrapper for this entity. */
+  toReference<Entity extends this = this>(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
+  /**
+   * Converts the entity to a plain object representation.
+   *
+   * **Note on typing with `Loaded` entities:** When called on a `Loaded<Entity, 'relation'>` type,
+   * the return type will be `EntityDTO<Entity>` (with relations as primary keys), not
+   * `EntityDTO<Loaded<Entity, 'relation'>>` (with loaded relations as nested objects).
+   * This is a TypeScript limitation - the `this` type resolves to the class, not the `Loaded` wrapper.
+   *
+   * For correct typing that reflects loaded relations, use `wrap()`:
+   * ```ts
+   * const result = await em.find(User, {}, { populate: ['profile'] });
+   * // Type: EntityDTO<User> (profile is number)
+   * const obj1 = result[0].toObject();
+   * // Type: EntityDTO<Loaded<User, 'profile'>> (profile is nested object)
+   * const obj2 = wrap(result[0]).toObject();
+   * ```
+   *
+   * Runtime values are correct in both cases - only the static types differ.
+   */
+  toObject<Entity extends this = this>(): EntityDTO<Entity>;
+  /**
+   * Converts the entity to a plain object representation.
+   *
+   * **Note on typing with `Loaded` entities:** When called on a `Loaded<Entity, 'relation'>` type,
+   * the return type will be `EntityDTO<Entity>` (with relations as primary keys), not
+   * `EntityDTO<Loaded<Entity, 'relation'>>` (with loaded relations as nested objects).
+   * This is a TypeScript limitation - the `this` type resolves to the class, not the `Loaded` wrapper.
+   *
+   * For correct typing that reflects loaded relations, use `wrap()`:
+   * ```ts
+   * const result = await em.find(User, {}, { populate: ['profile'] });
+   * // Type: EntityDTO<User> (profile is number)
+   * const obj1 = result[0].toObject();
+   * // Type: EntityDTO<Loaded<User, 'profile'>> (profile is nested object)
+   * const obj2 = wrap(result[0]).toObject();
+   * ```
+   *
+   * Runtime values are correct in both cases - only the static types differ.
+   */
+  toObject<Entity extends this = this>(ignoreFields: never[]): EntityDTO<Entity>;
+  /**
+   * Converts the entity to a plain object representation.
+   *
+   * **Note on typing with `Loaded` entities:** When called on a `Loaded<Entity, 'relation'>` type,
+   * the return type will be `EntityDTO<Entity>` (with relations as primary keys), not
+   * `EntityDTO<Loaded<Entity, 'relation'>>` (with loaded relations as nested objects).
+   * This is a TypeScript limitation - the `this` type resolves to the class, not the `Loaded` wrapper.
+   *
+   * For correct typing that reflects loaded relations, use `wrap()`:
+   * ```ts
+   * const result = await em.find(User, {}, { populate: ['profile'] });
+   * // Type: EntityDTO<User> (profile is number)
+   * const obj1 = result[0].toObject();
+   * // Type: EntityDTO<Loaded<User, 'profile'>> (profile is nested object)
+   * const obj2 = wrap(result[0]).toObject();
+   * ```
+   *
+   * Runtime values are correct in both cases - only the static types differ.
+   *
+   * @param ignoreFields - Array of field names to omit from the result.
+   */
+  toObject<Entity extends this = this, Ignored extends EntityKey<Entity> = never>(
+    ignoreFields: Ignored[],
+  ): Omit<EntityDTO<Entity>, Ignored>;
+  /** Converts the entity to a plain object, including all properties regardless of serialization rules. */
+  toPOJO<Entity extends this = this>(): EntityDTO<Entity>;
+  /** Serializes the entity with control over which relations and fields to include or exclude. */
+  serialize<
+    Entity extends this = this,
+    Naked extends FromEntityType<Entity> = FromEntityType<Entity>,
+    Hint extends string = never,
+    Exclude extends string = never,
+  >(options?: SerializeOptions<Naked, Hint, Exclude>): SerializeDTO<Naked, Hint, Exclude>;
+  /** Assigns the given data to this entity, updating its properties and relations. */
+  assign<
+    Entity extends this,
+    Naked extends FromEntityType<Entity> = FromEntityType<Entity>,
+    Convert extends boolean = false,
+    Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> =
+      | EntityData<Naked, Convert>
+      | Partial<EntityDTO<Naked>>,
+  >(
+    data: Data & IsSubset<EntityData<Naked>, Data>,
+    options?: AssignOptions<Convert>,
+  ): MergeSelected<Entity, Naked, keyof Data & string>;
+  /** Initializes (refreshes) the entity by reloading it from the database. Returns null if not found. */
+  init<
+    Entity extends this = this,
+    Hint extends string = never,
+    Fields extends string = '*',
+    Excludes extends string = never,
+  >(options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
+  /** Returns the database schema this entity belongs to. */
+  getSchema(): string | undefined;
+  /** Sets the database schema for this entity. */
+  setSchema(schema?: string): void;
 }

package/entity/BaseEntity.js

@@ -2,39 +2,50 @@ import { Reference } from './Reference.js';
 import { EntityAssigner } from './EntityAssigner.js';
 import { EntitySerializer } from '../serialization/EntitySerializer.js';
 import { helper } from './wrap.js';
+/** Base class for entities providing convenience methods like `assign()`, `toObject()`, and `populate()`. */
 export class BaseEntity {
-    isInitialized() {
-        return helper(this).__initialized;
-    }
-    populated(populated = true) {
-        helper(this).populated(populated);
-    }
-    async populate(populate, options = {}) {
-        return helper(this).populate(populate, options);
-    }
-    toReference() {
-        return Reference.create(this);
-    }
-    toObject(ignoreFields) {
-        return helper(this).toObject(ignoreFields);
-    }
-    toPOJO() {
-        return helper(this).toPOJO();
-    }
-    serialize(options) {
-        return EntitySerializer.serialize(this, options);
-    }
-    assign(data, options = {}) {
-        return EntityAssigner.assign(this, data, options);
-    }
-    init(options) {
-        return helper(this).init(options);
-    }
-    getSchema() {
-        return helper(this).getSchema();
-    }
-    setSchema(schema) {
-        helper(this).setSchema(schema);
-    }
+  /** Returns whether the entity has been fully loaded from the database. */
+  isInitialized() {
+    return helper(this).__initialized;
+  }
+  /** Marks the entity as populated or not for serialization purposes. */
+  populated(populated = true) {
+    helper(this).populated(populated);
+  }
+  /** Loads the specified relations on this entity. */
+  async populate(populate, options = {}) {
+    return helper(this).populate(populate, options);
+  }
+  /** Returns a Reference wrapper for this entity. */
+  toReference() {
+    return Reference.create(this);
+  }
+  toObject(ignoreFields) {
+    return helper(this).toObject(ignoreFields);
+  }
+  /** Converts the entity to a plain object, including all properties regardless of serialization rules. */
+  toPOJO() {
+    return helper(this).toPOJO();
+  }
+  /** Serializes the entity with control over which relations and fields to include or exclude. */
+  serialize(options) {
+    return EntitySerializer.serialize(this, options);
+  }
+  /** Assigns the given data to this entity, updating its properties and relations. */
+  assign(data, options = {}) {
+    return EntityAssigner.assign(this, data, options);
+  }
+  /** Initializes (refreshes) the entity by reloading it from the database. Returns null if not found. */
+  init(options) {
+    return helper(this).init(options);
+  }
+  /** Returns the database schema this entity belongs to. */
+  getSchema() {
+    return helper(this).getSchema();
+  }
+  /** Sets the database schema for this entity. */
+  setSchema(schema) {
+    helper(this).setSchema(schema);
+  }
 }
 Object.defineProperty(BaseEntity.prototype, '__baseEntity', { value: true, writable: false, enumerable: false });