@mikro-orm/core 7.0.0-dev.1 → 7.0.0-dev.100

package/drivers/DatabaseDriver.js

@@ -1,18 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseDriver = void 0;
-const IDatabaseDriver_1 = require("./IDatabaseDriver");
-const utils_1 = require("../utils");
-const enums_1 = require("../enums");
-const EntityManager_1 = require("../EntityManager");
-const errors_1 = require("../errors");
-const exceptions_1 = require("../exceptions");
-const wrap_1 = require("../entity/wrap");
-const JsonType_1 = require("../types/JsonType");
-class DatabaseDriver {
+import { EntityManagerType, } from './IDatabaseDriver.js';
+import { Utils } from '../utils/Utils.js';
+import { Cursor } from '../utils/Cursor.js';
+import { EntityComparator } from '../utils/EntityComparator.js';
+import { isRaw, raw } from '../utils/RawQueryFragment.js';
+import { QueryOrderNumeric, ReferenceKind } from '../enums.js';
+import { EntityManager } from '../EntityManager.js';
+import { CursorError, ValidationError } from '../errors.js';
+import { DriverException } from '../exceptions.js';
+import { helper } from '../entity/wrap.js';
+import { JsonType } from '../types/JsonType.js';
+import { MikroORM } from '../MikroORM.js';
+export class DatabaseDriver {
     config;
     dependencies;
-    [IDatabaseDriver_1.EntityManagerType];
+    [EntityManagerType];
     connection;
     replicas = [];
     platform;
@@ -28,14 +29,14 @@ class DatabaseDriver {
         throw new Error(`Batch updates are not supported by ${this.constructor.name} driver`);
     }
     createEntityManager(useContext) {
-        const EntityManagerClass = this.config.get('entityManager', EntityManager_1.EntityManager);
+        const EntityManagerClass = this.config.get('entityManager', EntityManager);
         return new EntityManagerClass(this.config, this, this.metadata, useContext);
     }
-    /* istanbul ignore next */
+    /* v8 ignore next */
     async findVirtual(entityName, where, options) {
         throw new Error(`Virtual entities are not supported by ${this.constructor.name} driver.`);
     }
-    /* istanbul ignore next */
+    /* v8 ignore next */
     async countVirtual(entityName, where, options) {
         throw new Error(`Counting virtual entities is not supported by ${this.constructor.name} driver.`);
     }
@@ -47,17 +48,18 @@ class DatabaseDriver {
     }
     async syncCollections(collections, options) {
         for (const coll of collections) {
+            /* v8 ignore else */
             if (!coll.property.owner) {
                 if (coll.getSnapshot() === undefined) {
-                    throw errors_1.ValidationError.cannotModifyInverseCollection(coll.owner, coll.property);
+                    throw ValidationError.cannotModifyInverseCollection(coll.owner, coll.property);
                 }
                 continue;
             }
-            /* istanbul ignore next */
+            /* v8 ignore next */
             {
                 const pk = coll.property.targetMeta.primaryKeys[0];
                 const data = { [coll.property.name]: coll.getIdentifiers(pk) };
-                await this.nativeUpdate(coll.owner.constructor.name, (0, wrap_1.helper)(coll.owner).getPrimaryKey(), data, options);
+                await this.nativeUpdate(coll.owner.constructor.name, helper(coll.owner).getPrimaryKey(), data, options);
             }
         }
     }
@@ -67,21 +69,21 @@ class DatabaseDriver {
         }
         return this.comparator.mapResult(meta.className, result);
     }
-    async connect() {
-        await this.connection.connect();
+    async connect(options) {
+        await this.connection.connect(options);
         await Promise.all(this.replicas.map(replica => replica.connect()));
         return this.connection;
     }
-    async reconnect() {
+    async reconnect(options) {
         await this.close(true);
-        await this.connect();
+        await this.connect(options);
         return this.connection;
     }
     getConnection(type = 'write') {
         if (type === 'write' || this.replicas.length === 0) {
             return this.connection;
         }
-        const rand = utils_1.Utils.randomInt(0, this.replicas.length - 1);
+        const rand = Utils.randomInt(0, this.replicas.length - 1);
         return this.replicas[rand];
     }
     async close(force) {
@@ -93,7 +95,7 @@ class DatabaseDriver {
     }
     setMetadata(metadata) {
         this.metadata = metadata;
-        this.comparator = new utils_1.EntityComparator(this.metadata, this.platform);
+        this.comparator = new EntityComparator(this.metadata, this.platform);
         this.connection.setMetadata(metadata);
         this.connection.setPlatform(this.platform);
         this.replicas.forEach(replica => {
@@ -107,11 +109,20 @@ class DatabaseDriver {
     getDependencies() {
         return this.dependencies;
     }
+    isPopulated(meta, prop, hint, name) {
+        if (hint.field === prop.name || hint.field === name || hint.all) {
+            return true;
+        }
+        if (prop.embedded && hint.children && meta.properties[prop.embedded[0]].name === hint.field) {
+            return hint.children.some(c => this.isPopulated(meta, prop, c, prop.embedded[1]));
+        }
+        return false;
+    }
     processCursorOptions(meta, options, orderBy) {
         const { first, last, before, after, overfetch } = options;
         const limit = first ?? last;
         const isLast = !first && !!last;
-        const definition = utils_1.Cursor.getDefinition(meta, orderBy);
+        const definition = Cursor.getDefinition(meta, orderBy);
         const $and = [];
         // allow POJO as well, we care only about the correct key being present
         const isCursor = (val, key) => {
@@ -119,15 +130,15 @@ class DatabaseDriver {
         };
         const createCursor = (val, key, inverse = false) => {
             let def = isCursor(val, key) ? val[key] : val;
-            if (utils_1.Utils.isPlainObject(def)) {
-                def = utils_1.Cursor.for(meta, def, orderBy);
+            if (Utils.isPlainObject(def)) {
+                def = Cursor.for(meta, def, orderBy);
             }
-            /* istanbul ignore next */
-            const offsets = def ? utils_1.Cursor.decode(def) : [];
+            /* v8 ignore next */
+            const offsets = def ? Cursor.decode(def) : [];
             if (definition.length === offsets.length) {
                 return this.createCursorCondition(definition, offsets, inverse, meta);
             }
-            /* istanbul ignore next */
+            /* v8 ignore next */
             return {};
         };
         if (after) {
@@ -140,15 +151,15 @@ class DatabaseDriver {
             options.limit = limit + (overfetch ? 1 : 0);
         }
         const createOrderBy = (prop, direction) => {
-            if (utils_1.Utils.isPlainObject(direction)) {
-                const value = utils_1.Utils.keys(direction).reduce((o, key) => {
+            if (Utils.isPlainObject(direction)) {
+                const value = Utils.keys(direction).reduce((o, key) => {
                     Object.assign(o, createOrderBy(key, direction[key]));
                     return o;
                 }, {});
                 return ({ [prop]: value });
             }
-            const desc = direction === enums_1.QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
-            const dir = utils_1.Utils.xor(desc, isLast) ? 'desc' : 'asc';
+            const desc = direction === QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
+            const dir = Utils.xor(desc, isLast) ? 'desc' : 'asc';
             return ({ [prop]: dir });
         };
         return {
@@ -156,24 +167,23 @@ class DatabaseDriver {
             where: ($and.length > 1 ? { $and } : { ...$and[0] }),
         };
     }
-    /* istanbul ignore next */
     createCursorCondition(definition, offsets, inverse, meta) {
         const createCondition = (prop, direction, offset, eq = false) => {
             if (offset === null) {
-                throw errors_1.CursorError.missingValue(meta.className, prop);
+                throw CursorError.missingValue(meta.className, prop);
             }
-            if (utils_1.Utils.isPlainObject(direction)) {
-                const value = utils_1.Utils.keys(direction).reduce((o, key) => {
-                    if (utils_1.Utils.isEmpty(offset[key])) {
-                        throw errors_1.CursorError.missingValue(meta.className, `${prop}.${key}`);
+            if (Utils.isPlainObject(direction)) {
+                const value = Utils.keys(direction).reduce((o, key) => {
+                    if (Utils.isEmpty(offset[key])) {
+                        throw CursorError.missingValue(meta.className, `${prop}.${key}`);
                     }
                     Object.assign(o, createCondition(key, direction[key], offset[key], eq));
                     return o;
                 }, {});
                 return ({ [prop]: value });
             }
-            const desc = direction === enums_1.QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
-            const operator = utils_1.Utils.xor(desc, inverse) ? '$lt' : '$gt';
+            const desc = direction === QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
+            const operator = Utils.xor(desc, inverse) ? '$lt' : '$gt';
             return { [prop]: { [operator + (eq ? 'e' : '')]: offset } };
         };
         const [order, ...otherOrders] = definition;
@@ -222,7 +232,7 @@ class DatabaseDriver {
                 return;
             }
             if (prop.joinColumns && Array.isArray(data[k])) {
-                const copy = utils_1.Utils.flatten(data[k]);
+                const copy = Utils.flatten(data[k]);
                 delete data[k];
                 prop.joinColumns.forEach((joinColumn, idx) => data[joinColumn] = copy[idx]);
                 return;
@@ -232,49 +242,49 @@ class DatabaseDriver {
                 prop.ownColumns.forEach(joinColumn => data[joinColumn] = null);
                 return;
             }
-            if (prop.customType && convertCustomTypes && !(prop.customType instanceof JsonType_1.JsonType && object) && !(0, utils_1.isRaw)(data[k])) {
+            if (prop.customType && convertCustomTypes && !(prop.customType instanceof JsonType && object) && !isRaw(data[k])) {
                 data[k] = prop.customType.convertToDatabaseValue(data[k], this.platform, { fromQuery: true, key: k, mode: 'query-data' });
             }
-            if (prop.hasConvertToDatabaseValueSQL && !prop.object && !(0, utils_1.isRaw)(data[k])) {
+            if (prop.hasConvertToDatabaseValueSQL && !prop.object && !isRaw(data[k])) {
                 const quoted = this.platform.quoteValue(data[k]);
                 const sql = prop.customType.convertToDatabaseValueSQL(quoted, this.platform);
-                data[k] = (0, utils_1.raw)(sql.replace(/\?/g, '\\?'));
+                data[k] = raw(sql.replace(/\?/g, '\\?'));
             }
             if (prop.fieldNames) {
-                utils_1.Utils.renameKey(data, k, prop.fieldNames[0]);
+                Utils.renameKey(data, k, prop.fieldNames[0]);
             }
         });
         return data;
     }
     inlineEmbeddables(meta, data, where) {
-        /* istanbul ignore next */
+        /* v8 ignore next */
         if (data == null) {
             return;
         }
-        utils_1.Utils.keys(data).forEach(k => {
-            if (utils_1.Utils.isOperator(k)) {
-                utils_1.Utils.asArray(data[k]).forEach(payload => this.inlineEmbeddables(meta, payload, where));
+        Utils.keys(data).forEach(k => {
+            if (Utils.isOperator(k)) {
+                Utils.asArray(data[k]).forEach(payload => this.inlineEmbeddables(meta, payload, where));
             }
         });
         meta.props.forEach(prop => {
-            if (prop.kind === enums_1.ReferenceKind.EMBEDDED && prop.object && !where && utils_1.Utils.isObject(data[prop.name])) {
+            if (prop.kind === ReferenceKind.EMBEDDED && prop.object && !where && Utils.isObject(data[prop.name])) {
                 return;
             }
-            if (prop.kind === enums_1.ReferenceKind.EMBEDDED && utils_1.Utils.isObject(data[prop.name])) {
+            if (prop.kind === ReferenceKind.EMBEDDED && Utils.isObject(data[prop.name])) {
                 const props = prop.embeddedProps;
                 let unknownProp = false;
                 Object.keys(data[prop.name]).forEach(kk => {
                     // explicitly allow `$exists`, `$eq` and `$ne` operators here as they can't be misused this way
-                    const operator = Object.keys(data[prop.name]).some(f => utils_1.Utils.isOperator(f) && !['$exists', '$ne', '$eq'].includes(f));
+                    const operator = Object.keys(data[prop.name]).some(f => Utils.isOperator(f) && !['$exists', '$ne', '$eq'].includes(f));
                     if (operator) {
-                        throw errors_1.ValidationError.cannotUseOperatorsInsideEmbeddables(meta.className, prop.name, data);
+                        throw ValidationError.cannotUseOperatorsInsideEmbeddables(meta.className, prop.name, data);
                     }
                     if (prop.object && where) {
                         const inline = (payload, sub, path) => {
-                            if (sub.kind === enums_1.ReferenceKind.EMBEDDED && utils_1.Utils.isObject(payload[sub.embedded[1]])) {
+                            if (sub.kind === ReferenceKind.EMBEDDED && Utils.isObject(payload[sub.embedded[1]])) {
                                 return Object.keys(payload[sub.embedded[1]]).forEach(kkk => {
                                     if (!sub.embeddedProps[kkk]) {
-                                        throw errors_1.ValidationError.invalidEmbeddableQuery(meta.className, kkk, sub.type);
+                                        throw ValidationError.invalidEmbeddableQuery(meta.className, kkk, sub.type);
                                     }
                                     inline(payload[sub.embedded[1]], sub.embeddedProps[kkk], [...path, sub.embedded[1]]);
                                 });
@@ -284,7 +294,7 @@ class DatabaseDriver {
                         const parentPropName = kk.substring(0, kk.indexOf('.'));
                         // we might be using some native JSON operator, e.g. with mongodb's `$geoWithin` or `$exists`
                         if (props[kk]) {
-                            /* istanbul ignore next */
+                            /* v8 ignore next */
                             inline(data[prop.name], props[kk] || props[parentPropName], [prop.name]);
                         }
                         else if (props[parentPropName]) {
@@ -298,7 +308,7 @@ class DatabaseDriver {
                         data[props[kk].name] = data[prop.name][props[kk].embedded[1]];
                     }
                     else {
-                        throw errors_1.ValidationError.invalidEmbeddableQuery(meta.className, kk, prop.type);
+                        throw ValidationError.invalidEmbeddableQuery(meta.className, kk, prop.type);
                     }
                 });
                 if (!unknownProp) {
@@ -309,14 +319,14 @@ class DatabaseDriver {
     }
     getPrimaryKeyFields(entityName) {
         const meta = this.metadata.find(entityName);
-        return meta ? utils_1.Utils.flatten(meta.getPrimaryProps().map(pk => pk.fieldNames)) : [this.config.getNamingStrategy().referenceColumnName()];
+        return meta ? Utils.flatten(meta.getPrimaryProps().map(pk => pk.fieldNames)) : [this.config.getNamingStrategy().referenceColumnName()];
     }
     createReplicas(cb) {
         const replicas = this.config.get('replicas', []);
         const ret = [];
         const props = ['dbName', 'clientUrl', 'host', 'port', 'user', 'password', 'multipleStatements', 'pool', 'name', 'driverOptions'];
         for (const conf of replicas) {
-            const replicaConfig = utils_1.Utils.copy(conf);
+            const replicaConfig = Utils.copy(conf);
             for (const prop of props) {
                 if (conf[prop]) {
                     continue;
@@ -341,7 +351,7 @@ class DatabaseDriver {
      * @inheritDoc
      */
     convertException(exception) {
-        if (exception instanceof exceptions_1.DriverException) {
+        if (exception instanceof DriverException) {
             return exception;
         }
         return this.platform.getExceptionConverter().convertException(exception);
@@ -375,5 +385,8 @@ class DatabaseDriver {
         const schemaName = meta?.schema === '*' ? this.config.getSchema() : meta?.schema;
         return options?.schema ?? options?.parentSchema ?? schemaName ?? this.config.getSchema();
     }
+    /** @internal */
+    getORMClass() {
+        return MikroORM;
+    }
 }
-exports.DatabaseDriver = DatabaseDriver;

package/drivers/IDatabaseDriver.d.ts

@@ -1,22 +1,26 @@
-import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, QBFilterQuery, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate } from '../typings';
-import type { Connection, QueryResult, Transaction } from '../connections';
-import type { FlushMode, LockMode, QueryOrderMap, QueryFlag, LoadStrategy, PopulateHint, PopulatePath } from '../enums';
-import type { Platform } from '../platforms';
-import type { MetadataStorage } from '../metadata';
-import type { Collection } from '../entity/Collection';
-import type { EntityManager } from '../EntityManager';
-import type { DriverException } from '../exceptions';
-import type { Configuration } from '../utils/Configuration';
-import type { LoggingOptions, LogContext } from '../logging';
-import type { RawQueryFragment } from '../utils/RawQueryFragment';
+import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, QBFilterQuery, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate, EntityName } from '../typings.js';
+import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
+import type { FlushMode, LockMode, QueryOrderMap, QueryFlag, LoadStrategy, PopulateHint, PopulatePath } from '../enums.js';
+import type { Platform } from '../platforms/Platform.js';
+import type { MetadataStorage } from '../metadata/MetadataStorage.js';
+import type { Collection } from '../entity/Collection.js';
+import type { EntityManager } from '../EntityManager.js';
+import type { DriverException } from '../exceptions.js';
+import type { Configuration } from '../utils/Configuration.js';
+import type { LoggingOptions, LogContext } from '../logging/Logger.js';
+import type { RawQueryFragment } from '../utils/RawQueryFragment.js';
 export declare const EntityManagerType: unique symbol;
 export interface IDatabaseDriver<C extends Connection = Connection> {
     [EntityManagerType]: EntityManager<this>;
     readonly config: Configuration;
-    createEntityManager<D extends IDatabaseDriver = IDatabaseDriver>(useContext?: boolean): D[typeof EntityManagerType];
-    connect(): Promise<C>;
+    createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
+    connect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
     close(force?: boolean): Promise<void>;
-    reconnect(): Promise<C>;
+    reconnect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
     getConnection(type?: ConnectionType): C;
     /**
      * Finds selection of entities
@@ -27,6 +31,7 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
      */
     findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
     findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T>): AsyncIterableIterator<T>;
     nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
     nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
@@ -68,6 +73,18 @@ export type OrderDefinition<T> = (QueryOrderMap<T> & {
 export interface FindAllOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends FindOptions<T, P, F, E> {
     where?: FilterQuery<T>;
 }
+export interface StreamOptions<Entity, Populate extends string = never, Fields extends string = '*', Exclude extends string = never> extends Omit<FindAllOptions<Entity, Populate, Fields, Exclude>, 'cache' | 'before' | 'after' | 'first' | 'last' | 'overfetch' | 'strategy'> {
+    /**
+     * When populating to-many relations, the ORM streams fully merged entities instead of yielding every row.
+     * You can opt out of this behavior by specifying `mergeResults: false`. This will yield every row from
+     * the SQL result, but still mapped to entities, meaning that to-many collections will contain at most
+     * a single item, and you will get duplicate root entities when they have multiple items in the populated
+     * collection.
+     *
+     * @default true
+     */
+    mergeResults?: boolean;
+}
 export type FilterOptions = Dictionary<boolean | Dictionary> | string[] | boolean;
 export interface LoadHint<Entity, Hint extends string = never, Fields extends string = PopulatePath.ALL, Excludes extends string = never> {
     populate?: Populate<Entity, Hint>;
@@ -146,10 +163,13 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
     hintComments?: string | string[];
     loggerContext?: LogContext;
     logging?: LoggingOptions;
+    /** @internal used to apply filters to the auto-joined relations */
+    em?: EntityManager;
 }
-export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'offset'> {
+export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never, I extends boolean = true> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'offset'> {
+    includeCount?: I;
 }
-export interface FindOneOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
+export interface FindOneOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
     lockMode?: LockMode;
     lockVersion?: number | Date;
 }
@@ -163,6 +183,7 @@ export interface NativeInsertUpdateOptions<T> {
     schema?: string;
     /** `nativeUpdate()` only option */
     upsert?: boolean;
+    loggerContext?: LogContext;
 }
 export interface NativeInsertUpdateManyOptions<T> extends NativeInsertUpdateOptions<T> {
     processCollections?: boolean;
@@ -197,6 +218,8 @@ export interface CountOptions<T extends object, P extends string = never> {
     hintComments?: string | string[];
     loggerContext?: LogContext;
     logging?: LoggingOptions;
+    /** @internal used to apply filters to the auto-joined relations */
+    em?: EntityManager;
 }
 export interface UpdateOptions<T> {
     filters?: FilterOptions;
@@ -218,6 +241,7 @@ export interface LockOptions extends DriverMethodOptions {
 export interface DriverMethodOptions {
     ctx?: Transaction;
     schema?: string;
+    loggerContext?: LogContext;
 }
 export interface GetReferenceOptions {
     wrapped?: boolean;

package/drivers/IDatabaseDriver.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityManagerType = void 0;
-exports.EntityManagerType = Symbol('EntityManagerType');
+export const EntityManagerType = Symbol('EntityManagerType');

package/drivers/index.d.ts

@@ -1,2 +1,2 @@
-export * from './IDatabaseDriver';
-export * from './DatabaseDriver';
+export * from './IDatabaseDriver.js';
+export * from './DatabaseDriver.js';

package/drivers/index.js

@@ -1,18 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./IDatabaseDriver"), exports);
-__exportStar(require("./DatabaseDriver"), exports);
+export * from './IDatabaseDriver.js';
+export * from './DatabaseDriver.js';

package/entity/BaseEntity.d.ts

@@ -1,12 +1,11 @@
-import { type Ref } from './Reference';
-import type { AutoPath, EntityData, EntityDTO, Loaded, LoadedReference, AddEager, EntityKey, FromEntityType, IsSubset, MergeSelected } from '../typings';
-import { type AssignOptions } from './EntityAssigner';
-import type { EntityLoaderOptions } from './EntityLoader';
-import { type SerializeOptions } from '../serialization/EntitySerializer';
-import type { FindOneOptions } from '../drivers/IDatabaseDriver';
+import { type Ref } from './Reference.js';
+import type { AutoPath, EntityData, EntityDTO, Loaded, LoadedReference, AddEager, EntityKey, FromEntityType, IsSubset, MergeSelected } 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';
 export declare abstract class BaseEntity {
     isInitialized(): boolean;
-    isTouched(): boolean;
     populated(populated?: boolean): void;
     populate<Entity extends this = this, Hint extends string = never>(populate: AutoPath<Entity, Hint>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
     toReference<Entity extends this = this>(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;

package/entity/BaseEntity.js

@@ -1,47 +1,40 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseEntity = void 0;
-const Reference_1 = require("./Reference");
-const EntityAssigner_1 = require("./EntityAssigner");
-const EntitySerializer_1 = require("../serialization/EntitySerializer");
-const wrap_1 = require("./wrap");
-class BaseEntity {
+import { Reference } from './Reference.js';
+import { EntityAssigner } from './EntityAssigner.js';
+import { EntitySerializer } from '../serialization/EntitySerializer.js';
+import { helper } from './wrap.js';
+export class BaseEntity {
     isInitialized() {
-        return (0, wrap_1.helper)(this).__initialized;
-    }
-    isTouched() {
-        return (0, wrap_1.helper)(this).__touched;
+        return helper(this).__initialized;
     }
     populated(populated = true) {
-        (0, wrap_1.helper)(this).populated(populated);
+        helper(this).populated(populated);
     }
     async populate(populate, options = {}) {
-        return (0, wrap_1.helper)(this).populate(populate, options);
+        return helper(this).populate(populate, options);
     }
     toReference() {
-        return Reference_1.Reference.create(this);
+        return Reference.create(this);
     }
     toObject(ignoreFields) {
-        return (0, wrap_1.helper)(this).toObject(ignoreFields);
+        return helper(this).toObject(ignoreFields);
     }
     toPOJO() {
-        return (0, wrap_1.helper)(this).toPOJO();
+        return helper(this).toPOJO();
     }
     serialize(options) {
-        return EntitySerializer_1.EntitySerializer.serialize(this, options);
+        return EntitySerializer.serialize(this, options);
     }
     assign(data, options = {}) {
-        return EntityAssigner_1.EntityAssigner.assign(this, data, options);
+        return EntityAssigner.assign(this, data, options);
     }
     init(options) {
-        return (0, wrap_1.helper)(this).init(options);
+        return helper(this).init(options);
     }
     getSchema() {
-        return (0, wrap_1.helper)(this).getSchema();
+        return helper(this).getSchema();
     }
     setSchema(schema) {
-        (0, wrap_1.helper)(this).setSchema(schema);
+        helper(this).setSchema(schema);
     }
 }
-exports.BaseEntity = BaseEntity;
 Object.defineProperty(BaseEntity.prototype, '__baseEntity', { value: true, writable: false, enumerable: false });