@mikro-orm/core 7.0.0-dev.0 → 7.0.0-dev.2

package/decorators/index.js

@@ -1,36 +1,17 @@
-"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 });
-exports.OneToMany = void 0;
-/* istanbul ignore file */
-__exportStar(require("./PrimaryKey"), exports);
-__exportStar(require("./Entity"), exports);
-__exportStar(require("./OneToOne"), exports);
-__exportStar(require("./ManyToOne"), exports);
-__exportStar(require("./ManyToMany"), exports);
-var OneToMany_1 = require("./OneToMany");
-Object.defineProperty(exports, "OneToMany", { enumerable: true, get: function () { return OneToMany_1.OneToMany; } });
-__exportStar(require("./Property"), exports);
-__exportStar(require("./Check"), exports);
-__exportStar(require("./Enum"), exports);
-__exportStar(require("./Formula"), exports);
-__exportStar(require("./Indexed"), exports);
-__exportStar(require("./Embeddable"), exports);
-__exportStar(require("./Embedded"), exports);
-__exportStar(require("./Filter"), exports);
-__exportStar(require("./CreateRequestContext"), exports);
-__exportStar(require("./hooks"), exports);
-__exportStar(require("./Transactional"), exports);
+export * from './PrimaryKey.js';
+export * from './Entity.js';
+export * from './OneToOne.js';
+export * from './ManyToOne.js';
+export * from './ManyToMany.js';
+export { OneToMany } from './OneToMany.js';
+export * from './Property.js';
+export * from './Check.js';
+export * from './Enum.js';
+export * from './Formula.js';
+export * from './Indexed.js';
+export * from './Embeddable.js';
+export * from './Embedded.js';
+export * from './Filter.js';
+export * from './CreateRequestContext.js';
+export * from './hooks.js';
+export * from './Transactional.js';

package/drivers/DatabaseDriver.d.ts

@@ -1,14 +1,15 @@
-import { type CountOptions, type DeleteOptions, type DriverMethodOptions, EntityManagerType, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition } from './IDatabaseDriver';
-import type { ConnectionType, Dictionary, EntityData, EntityDictionary, EntityMetadata, EntityProperty, FilterQuery, PopulateOptions, Primary } from '../typings';
-import type { MetadataStorage } from '../metadata';
-import type { Connection, QueryResult, Transaction } from '../connections';
-import { type Configuration, type ConnectionOptions, EntityComparator } from '../utils';
-import { type QueryOrder } from '../enums';
-import type { Platform } from '../platforms';
-import type { Collection } from '../entity/Collection';
-import { EntityManager } from '../EntityManager';
-import { DriverException } from '../exceptions';
-import type { Logger } from '../logging/Logger';
+import { type CountOptions, type DeleteOptions, type DriverMethodOptions, EntityManagerType, type FindOneOptions, type FindOptions, type IDatabaseDriver, type LockOptions, type NativeInsertUpdateManyOptions, type NativeInsertUpdateOptions, type OrderDefinition } from './IDatabaseDriver.js';
+import type { ConnectionType, Dictionary, EntityData, EntityDictionary, EntityMetadata, EntityProperty, FilterQuery, PopulateOptions, Primary } from '../typings.js';
+import type { MetadataStorage } from '../metadata/MetadataStorage.js';
+import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
+import { type Configuration, type ConnectionOptions } from '../utils/Configuration.js';
+import { EntityComparator } from '../utils/EntityComparator.js';
+import { type QueryOrder } from '../enums.js';
+import type { Platform } from '../platforms/Platform.js';
+import type { Collection } from '../entity/Collection.js';
+import { EntityManager } from '../EntityManager.js';
+import { DriverException } from '../exceptions.js';
+import type { Logger } from '../logging/Logger.js';
 export declare abstract class DatabaseDriver<C extends Connection> implements IDatabaseDriver<C> {
     readonly config: Configuration;
     protected readonly dependencies: string[];
@@ -28,7 +29,7 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
     abstract nativeDelete<T extends object>(entityName: string, where: FilterQuery<T>, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
     abstract count<T extends object, P extends string = never>(entityName: string, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
-    createEntityManager<D extends IDatabaseDriver = IDatabaseDriver>(useContext?: boolean): D[typeof EntityManagerType];
+    createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
     findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
     countVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
     aggregate(entityName: string, pipeline: any[]): Promise<any[]>;

package/drivers/DatabaseDriver.js

@@ -1,18 +1,18 @@
-"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';
+export class DatabaseDriver {
     config;
     dependencies;
-    [IDatabaseDriver_1.EntityManagerType];
+    [EntityManagerType];
     connection;
     replicas = [];
     platform;
@@ -28,14 +28,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 3 */
     async findVirtual(entityName, where, options) {
         throw new Error(`Virtual entities are not supported by ${this.constructor.name} driver.`);
     }
-    /* istanbul ignore next */
+    /* v8 ignore next 3 */
     async countVirtual(entityName, where, options) {
         throw new Error(`Counting virtual entities is not supported by ${this.constructor.name} driver.`);
     }
@@ -49,16 +49,14 @@ class DatabaseDriver {
         for (const coll of collections) {
             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 */
-            {
-                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);
-            }
+            /* v8 ignore next 3 */
+            const pk = coll.property.targetMeta.primaryKeys[0];
+            const data = { [coll.property.name]: coll.getIdentifiers(pk) };
+            await this.nativeUpdate(coll.owner.constructor.name, helper(coll.owner).getPrimaryKey(), data, options);
         }
     }
     mapResult(result, meta, populate = []) {
@@ -81,7 +79,7 @@ class DatabaseDriver {
         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 +91,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 => {
@@ -111,7 +109,7 @@ class DatabaseDriver {
         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 +117,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 +138,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 +154,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 +219,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 +229,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 3 */
         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 +281,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 +295,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 +306,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 +338,7 @@ class DatabaseDriver {
      * @inheritDoc
      */
     convertException(exception) {
-        if (exception instanceof exceptions_1.DriverException) {
+        if (exception instanceof DriverException) {
             return exception;
         }
         return this.platform.getExceptionConverter().convertException(exception);
@@ -376,4 +373,3 @@ class DatabaseDriver {
         return options?.schema ?? options?.parentSchema ?? schemaName ?? this.config.getSchema();
     }
 }
-exports.DatabaseDriver = DatabaseDriver;

package/drivers/IDatabaseDriver.d.ts

@@ -1,19 +1,19 @@
-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 } 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];
+    createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
     connect(): Promise<C>;
     close(force?: boolean): Promise<void>;
     reconnect(): Promise<C>;

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/ArrayCollection.d.ts

@@ -1,6 +1,6 @@
 import { inspect } from 'node:util';
-import type { EntityDTO, EntityProperty, IPrimaryKey, Primary } from '../typings';
-import { Reference } from './Reference';
+import type { EntityDTO, EntityProperty, IPrimaryKey, Primary } from '../typings.js';
+import { Reference } from './Reference.js';
 export declare class ArrayCollection<T extends object, O extends object> {
     readonly owner: O;
     protected readonly items: Set<T>;

package/entity/ArrayCollection.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArrayCollection = void 0;
-const node_util_1 = require("node:util");
-const Reference_1 = require("./Reference");
-const wrap_1 = require("./wrap");
-const errors_1 = require("../errors");
-const enums_1 = require("../enums");
-const Utils_1 = require("../utils/Utils");
-class ArrayCollection {
+import { inspect } from 'node:util';
+import { Reference } from './Reference.js';
+import { helper, wrap } from './wrap.js';
+import { MetadataError, ValidationError } from '../errors.js';
+import { ReferenceKind } from '../enums.js';
+import { Utils } from '../utils/Utils.js';
+export class ArrayCollection {
     owner;
     items = new Set();
     initialized = true;
@@ -17,7 +14,7 @@ class ArrayCollection {
     _property;
     constructor(owner, items) {
         this.owner = owner;
-        /* istanbul ignore next */
+        /* v8 ignore next 5 */
         if (items) {
             let i = 0;
             this.items = new Set(items);
@@ -36,7 +33,7 @@ class ArrayCollection {
         }
         const meta = this.property.targetMeta;
         const args = meta.toJsonParams.map(() => undefined);
-        return this.map(item => (0, wrap_1.wrap)(item).toJSON(...args));
+        return this.map(item => wrap(item).toJSON(...args));
     }
     toJSON() {
         return this.toArray();
@@ -48,16 +45,16 @@ class ArrayCollection {
         }
         field ??= this.property.targetMeta.serializedPrimaryKey;
         return items.map(i => {
-            if (Utils_1.Utils.isEntity(i[field], true)) {
-                return (0, wrap_1.wrap)(i[field], true).getPrimaryKey();
+            if (Utils.isEntity(i[field], true)) {
+                return wrap(i[field], true).getPrimaryKey();
             }
             return i[field];
         });
     }
     add(entity, ...entities) {
-        entities = Utils_1.Utils.asArray(entity).concat(entities);
+        entities = Utils.asArray(entity).concat(entities);
         for (const item of entities) {
-            const entity = Reference_1.Reference.unwrapReference(item);
+            const entity = Reference.unwrapReference(item);
             if (!this.contains(entity, false)) {
                 this.incrementCount(1);
                 this[this.items.size] = entity;
@@ -82,7 +79,7 @@ class ArrayCollection {
             this.initialized = true;
             this.snapshot = undefined;
         }
-        if (this.compare(Utils_1.Utils.asArray(items).map(item => Reference_1.Reference.unwrapReference(item)))) {
+        if (this.compare(Utils.asArray(items).map(item => Reference.unwrapReference(item)))) {
             return;
         }
         this.remove(this.items);
@@ -120,13 +117,13 @@ class ArrayCollection {
      * which tells the ORM we don't want orphaned entities to exist, so we know those should be removed.
      */
     remove(entity, ...entities) {
-        entities = Utils_1.Utils.asArray(entity).concat(entities);
+        entities = Utils.asArray(entity).concat(entities);
         let modified = false;
         for (const item of entities) {
             if (!item) {
                 continue;
             }
-            const entity = Reference_1.Reference.unwrapReference(item);
+            const entity = Reference.unwrapReference(item);
             if (this.items.delete(entity)) {
                 this.incrementCount(-1);
                 delete this[this.items.size]; // remove last item
@@ -164,7 +161,7 @@ class ArrayCollection {
         this.dirty = true;
     }
     contains(item, check) {
-        const entity = Reference_1.Reference.unwrapReference(item);
+        const entity = Reference.unwrapReference(item);
         return this.items.has(entity);
     }
     /**
@@ -261,7 +258,7 @@ class ArrayCollection {
             return this.initialized;
         }
         for (const item of this.items) {
-            if (!(0, wrap_1.helper)(item).__initialized) {
+            if (!helper(item).__initialized) {
                 return false;
             }
         }
@@ -307,10 +304,10 @@ class ArrayCollection {
      */
     get property() {
         if (!this._property) {
-            const meta = (0, wrap_1.wrap)(this.owner, true).__meta;
-            /* istanbul ignore if */
+            const meta = wrap(this.owner, true).__meta;
+            /* v8 ignore next 3 */
             if (!meta) {
-                throw errors_1.MetadataError.fromUnknownEntity(this.owner.constructor.name, 'Collection.property getter, maybe you just forgot to initialize the ORM?');
+                throw MetadataError.fromUnknownEntity(this.owner.constructor.name, 'Collection.property getter, maybe you just forgot to initialize the ORM?');
             }
             this._property = meta.relations.find(prop => this.owner[prop.name] === this);
         }
@@ -340,27 +337,27 @@ class ArrayCollection {
     propagateToOwningSide(item, method) {
         const mappedBy = this.property.mappedBy;
         const collection = item[mappedBy];
-        if (this.property.kind === enums_1.ReferenceKind.MANY_TO_MANY) {
+        if (this.property.kind === ReferenceKind.MANY_TO_MANY) {
             if (this.shouldPropagateToCollection(collection, method)) {
                 collection[method](this.owner);
             }
         }
-        else if (this.property.kind === enums_1.ReferenceKind.ONE_TO_MANY && method !== 'takeSnapshot') {
+        else if (this.property.kind === ReferenceKind.ONE_TO_MANY && method !== 'takeSnapshot') {
             const prop2 = this.property.targetMeta.properties[mappedBy];
-            const owner = prop2.mapToPk ? (0, wrap_1.helper)(this.owner).getPrimaryKey() : this.owner;
+            const owner = prop2.mapToPk ? helper(this.owner).getPrimaryKey() : this.owner;
             const value = method === 'add' ? owner : null;
             if (this.property.orphanRemoval && method === 'remove') {
                 // cache the PK before we propagate, as its value might be needed when flushing
-                (0, wrap_1.helper)(item).__pk = (0, wrap_1.helper)(item).getPrimaryKey();
+                helper(item).__pk = helper(item).getPrimaryKey();
             }
             if (!prop2.nullable && prop2.deleteRule !== 'cascade' && method === 'remove') {
                 if (!this.property.orphanRemoval) {
-                    throw errors_1.ValidationError.cannotRemoveFromCollectionWithoutOrphanRemoval(this.owner, this.property);
+                    throw ValidationError.cannotRemoveFromCollectionWithoutOrphanRemoval(this.owner, this.property);
                 }
                 return;
             }
             // skip if already propagated
-            if (Reference_1.Reference.unwrapReference(item[mappedBy]) !== value) {
+            if (Reference.unwrapReference(item[mappedBy]) !== value) {
                 item[mappedBy] = value;
             }
         }
@@ -384,16 +381,15 @@ class ArrayCollection {
         }
     }
     /** @ignore */
-    [node_util_1.inspect.custom](depth = 2) {
+    [inspect.custom](depth = 2) {
         const object = { ...this };
         const hidden = ['items', 'owner', '_property', '_count', 'snapshot', '_populated', '_snapshot', '_lazyInitialized', '_em', 'readonly'];
         hidden.forEach(k => delete object[k]);
-        const ret = (0, node_util_1.inspect)(object, { depth });
+        const ret = inspect(object, { depth });
         const name = `${this.constructor.name}<${this.property?.type ?? 'unknown'}>`;
         return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
     }
 }
-exports.ArrayCollection = ArrayCollection;
 Object.defineProperties(ArrayCollection.prototype, {
     __collection: { value: true, enumerable: false, writable: false },
 });