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

package/metadata/MetadataProvider.d.ts

@@ -1,5 +1,5 @@
-import type { EntityMetadata } from '../typings';
-import type { Logger } from '../logging/Logger';
+import type { EntityMetadata } from '../typings.js';
+import type { Logger } from '../logging/Logger.js';
 export interface IConfiguration {
     get(key: string, defaultValue?: any): any;
     getLogger(): Logger;

package/metadata/MetadataProvider.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataProvider = void 0;
-const Utils_1 = require("../utils/Utils");
-class MetadataProvider {
+import { Utils } from '../utils/Utils.js';
+export class MetadataProvider {
     config;
     constructor(config) {
         this.config = config;
@@ -10,14 +7,14 @@ class MetadataProvider {
     loadFromCache(meta, cache) {
         Object.values(cache.properties).forEach(prop => {
             const metaProp = meta.properties[prop.name];
+            /* v8 ignore next 3 */
             if (metaProp?.enum && Array.isArray(metaProp.items)) {
                 delete prop.items;
             }
         });
-        Utils_1.Utils.mergeConfig(meta, cache);
+        Utils.mergeConfig(meta, cache);
     }
     useCache() {
         return this.config.get('metadataCache').enabled ?? false;
     }
 }
-exports.MetadataProvider = MetadataProvider;

package/metadata/MetadataStorage.d.ts

@@ -1,5 +1,5 @@
-import { EntityMetadata, type Dictionary, type EntityData, type EntityName } from '../typings';
-import type { EntityManager } from '../EntityManager';
+import { EntityMetadata, type Dictionary, type EntityData, type EntityName } from '../typings.js';
+import type { EntityManager } from '../EntityManager.js';
 export declare class MetadataStorage {
     static readonly PATH_SYMBOL: unique symbol;
     private static readonly metadata;

package/metadata/MetadataStorage.js

@@ -1,21 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataStorage = void 0;
-const typings_1 = require("../typings");
-const Utils_1 = require("../utils/Utils");
-const errors_1 = require("../errors");
-const EntityHelper_1 = require("../entity/EntityHelper");
-class MetadataStorage {
+import { EntityMetadata } from '../typings.js';
+import { Utils } from '../utils/Utils.js';
+import { MetadataError } from '../errors.js';
+import { EntityHelper } from '../entity/EntityHelper.js';
+export class MetadataStorage {
     static PATH_SYMBOL = Symbol('MetadataStorage.PATH_SYMBOL');
-    static metadata = Utils_1.Utils.getGlobalStorage('metadata');
+    static metadata = Utils.getGlobalStorage('metadata');
     metadata;
     constructor(metadata = {}) {
-        this.metadata = Utils_1.Utils.copy(metadata, false);
+        this.metadata = Utils.copy(metadata, false);
     }
     static getMetadata(entity, path) {
-        const key = entity && path ? entity + '-' + Utils_1.Utils.hash(path) : null;
+        const key = entity && path ? entity + '-' + Utils.hash(path) : null;
         if (key && !MetadataStorage.metadata[key]) {
-            MetadataStorage.metadata[key] = new typings_1.EntityMetadata({ className: entity, path });
+            MetadataStorage.metadata[key] = new EntityMetadata({ className: entity, path });
         }
         if (key) {
             return MetadataStorage.metadata[key];
@@ -27,7 +24,7 @@ class MetadataStorage {
     }
     static getMetadataFromDecorator(target) {
         if (!Object.hasOwn(target, MetadataStorage.PATH_SYMBOL)) {
-            Object.defineProperty(target, MetadataStorage.PATH_SYMBOL, { value: Utils_1.Utils.lookupPathFromDecorator(target.name), writable: true });
+            Object.defineProperty(target, MetadataStorage.PATH_SYMBOL, { value: Utils.lookupPathFromDecorator(target.name), writable: true });
         }
         return MetadataStorage.getMetadata(target.name, target[MetadataStorage.PATH_SYMBOL]);
     }
@@ -49,12 +46,12 @@ class MetadataStorage {
         return this.metadata[type];
     }
     get(entityName, init = false, validate = true) {
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         if (validate && !init && !this.has(entityName)) {
-            throw errors_1.MetadataError.missingMetadata(entityName);
+            throw MetadataError.missingMetadata(entityName);
         }
         if (init && !this.has(entityName)) {
-            this.metadata[entityName] = new typings_1.EntityMetadata();
+            this.metadata[entityName] = new EntityMetadata();
         }
         return this.metadata[entityName];
     }
@@ -62,7 +59,7 @@ class MetadataStorage {
         if (!entityName) {
             return;
         }
-        entityName = Utils_1.Utils.className(entityName);
+        entityName = Utils.className(entityName);
         return this.metadata[entityName];
     }
     has(entity) {
@@ -77,7 +74,7 @@ class MetadataStorage {
     decorate(em) {
         Object.values(this.metadata)
             .filter(meta => meta.prototype)
-            .forEach(meta => EntityHelper_1.EntityHelper.decorate(meta, em));
+            .forEach(meta => EntityHelper.decorate(meta, em));
     }
     *[Symbol.iterator]() {
         for (const meta of Object.values(this.metadata)) {
@@ -85,4 +82,3 @@ class MetadataStorage {
         }
     }
 }
-exports.MetadataStorage = MetadataStorage;

package/metadata/MetadataValidator.d.ts

@@ -1,7 +1,7 @@
-import type { EntityMetadata } from '../typings';
-import { type MetadataDiscoveryOptions } from '../utils';
-import { ReferenceKind } from '../enums';
-import type { MetadataStorage } from './MetadataStorage';
+import type { EntityMetadata } from '../typings.js';
+import { type MetadataDiscoveryOptions } from '../utils/Configuration.js';
+import { ReferenceKind } from '../enums.js';
+import type { MetadataStorage } from './MetadataStorage.js';
 /**
  * @internal
  */

package/metadata/MetadataValidator.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataValidator = void 0;
-const utils_1 = require("../utils");
-const errors_1 = require("../errors");
-const enums_1 = require("../enums");
+import { Utils } from '../utils/Utils.js';
+import { MetadataError } from '../errors.js';
+import { ReferenceKind } from '../enums.js';
 /**
  * @internal
  */
-class MetadataValidator {
+export class MetadataValidator {
     /**
      * Validate there is only one property decorator. This disallows using `@Property()` together with e.g. `@ManyToOne()`
      * on the same property. One should use only `@ManyToOne()` in such case.
@@ -15,59 +12,59 @@ class MetadataValidator {
      */
     static validateSingleDecorator(meta, propertyName, reference) {
         if (meta.properties[propertyName] && meta.properties[propertyName].kind !== reference) {
-            throw errors_1.MetadataError.multipleDecorators(meta.className, propertyName);
+            throw MetadataError.multipleDecorators(meta.className, propertyName);
         }
     }
     validateEntityDefinition(metadata, name, options) {
         const meta = metadata.get(name);
         if (meta.virtual || meta.expression) {
-            for (const prop of utils_1.Utils.values(meta.properties)) {
-                if (![enums_1.ReferenceKind.SCALAR, enums_1.ReferenceKind.EMBEDDED, enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
-                    throw new errors_1.MetadataError(`Only scalars, embedded properties and to-many relations are allowed inside virtual entity. Found '${prop.kind}' in ${meta.className}.${prop.name}`);
+            for (const prop of Utils.values(meta.properties)) {
+                if (![ReferenceKind.SCALAR, ReferenceKind.EMBEDDED, ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                    throw new MetadataError(`Only scalars, embedded properties and to-many relations are allowed inside virtual entity. Found '${prop.kind}' in ${meta.className}.${prop.name}`);
                 }
                 if (prop.primary) {
-                    throw new errors_1.MetadataError(`Virtual entity ${meta.className} cannot have primary key ${meta.className}.${prop.name}`);
+                    throw new MetadataError(`Virtual entity ${meta.className} cannot have primary key ${meta.className}.${prop.name}`);
                 }
             }
             return;
         }
         // entities have PK
         if (!meta.embeddable && (!meta.primaryKeys || meta.primaryKeys.length === 0)) {
-            throw errors_1.MetadataError.fromMissingPrimaryKey(meta);
+            throw MetadataError.fromMissingPrimaryKey(meta);
         }
         this.validateVersionField(meta);
         this.validateDuplicateFieldNames(meta, options);
         this.validateIndexes(meta, meta.indexes ?? [], 'index');
         this.validateIndexes(meta, meta.uniques ?? [], 'unique');
-        for (const prop of utils_1.Utils.values(meta.properties)) {
-            if (prop.kind !== enums_1.ReferenceKind.SCALAR) {
+        for (const prop of Utils.values(meta.properties)) {
+            if (prop.kind !== ReferenceKind.SCALAR) {
                 this.validateReference(meta, prop, metadata, options);
                 this.validateBidirectional(meta, prop, metadata);
             }
             else if (metadata.has(prop.type)) {
-                throw errors_1.MetadataError.propertyTargetsEntityType(meta, prop, metadata.get(prop.type));
+                throw MetadataError.propertyTargetsEntityType(meta, prop, metadata.get(prop.type));
             }
         }
     }
     validateDiscovered(discovered, options) {
         if (discovered.length === 0 && options.warnWhenNoEntities) {
-            throw errors_1.MetadataError.noEntityDiscovered();
+            throw MetadataError.noEntityDiscovered();
         }
-        const duplicates = utils_1.Utils.findDuplicates(discovered.map(meta => meta.className));
+        const duplicates = Utils.findDuplicates(discovered.map(meta => meta.className));
         if (duplicates.length > 0 && options.checkDuplicateEntities) {
-            throw errors_1.MetadataError.duplicateEntityDiscovered(duplicates);
+            throw MetadataError.duplicateEntityDiscovered(duplicates);
         }
         const tableNames = discovered.filter(meta => !meta.abstract && meta === meta.root && (meta.tableName || meta.collection) && meta.schema !== '*');
-        const duplicateTableNames = utils_1.Utils.findDuplicates(tableNames.map(meta => {
+        const duplicateTableNames = Utils.findDuplicates(tableNames.map(meta => {
             const tableName = meta.tableName || meta.collection;
             return (meta.schema ? '.' + meta.schema : '') + tableName;
         }));
         if (duplicateTableNames.length > 0 && options.checkDuplicateTableNames && options.checkDuplicateEntities) {
-            throw errors_1.MetadataError.duplicateEntityDiscovered(duplicateTableNames, 'table names');
+            throw MetadataError.duplicateEntityDiscovered(duplicateTableNames, 'table names');
         }
         // validate we found at least one entity (not just abstract/base entities)
         if (discovered.filter(meta => meta.name).length === 0 && options.warnWhenNoEntities) {
-            throw errors_1.MetadataError.onlyAbstractEntitiesDiscovered();
+            throw MetadataError.onlyAbstractEntitiesDiscovered();
         }
         const unwrap = (type) => type
             .replace(/Array<(.*)>/, '$1') // unwrap array
@@ -75,15 +72,15 @@ class MetadataValidator {
             .replace(/\((.*)\)/, '$1'); // unwrap union types
         const name = (p) => {
             if (typeof p === 'function') {
-                return utils_1.Utils.className(p());
+                return Utils.className(p());
             }
-            return utils_1.Utils.className(p);
+            return Utils.className(p);
         };
         const pivotProps = new Map();
         // check for not discovered entities
         discovered.forEach(meta => Object.values(meta.properties).forEach(prop => {
-            if (prop.kind !== enums_1.ReferenceKind.SCALAR && !unwrap(prop.type).split(/ ?\| ?/).every(type => discovered.find(m => m.className === type))) {
-                throw errors_1.MetadataError.fromUnknownEntity(prop.type, `${meta.className}.${prop.name}`);
+            if (prop.kind !== ReferenceKind.SCALAR && !unwrap(prop.type).split(/ ?\| ?/).every(type => discovered.find(m => m.className === type))) {
+                throw MetadataError.fromUnknownEntity(prop.type, `${meta.className}.${prop.name}`);
             }
             if (prop.pivotEntity) {
                 const props = pivotProps.get(name(prop.pivotEntity)) ?? [];
@@ -94,24 +91,24 @@ class MetadataValidator {
         pivotProps.forEach(props => {
             // if the pivot entity is used in more than one property, check if they are linked
             if (props.length > 1 && props.every(p => !p.prop.mappedBy && !p.prop.inversedBy)) {
-                throw errors_1.MetadataError.invalidManyToManyWithPivotEntity(props[0].meta, props[0].prop, props[1].meta, props[1].prop);
+                throw MetadataError.invalidManyToManyWithPivotEntity(props[0].meta, props[0].prop, props[1].meta, props[1].prop);
             }
         });
     }
     validateReference(meta, prop, metadata, options) {
         // references do have types
         if (!prop.type) {
-            throw errors_1.MetadataError.fromWrongTypeDefinition(meta, prop);
+            throw MetadataError.fromWrongTypeDefinition(meta, prop);
         }
         // references do have type of known entity
         if (!metadata.find(prop.type)) {
-            throw errors_1.MetadataError.fromWrongTypeDefinition(meta, prop);
+            throw MetadataError.fromWrongTypeDefinition(meta, prop);
         }
         if (metadata.find(prop.type).abstract && !metadata.find(prop.type).discriminatorColumn) {
-            throw errors_1.MetadataError.targetIsAbstract(meta, prop);
+            throw MetadataError.targetIsAbstract(meta, prop);
         }
-        if ([enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.persist === false && metadata.find(prop.type).compositePK && options.checkNonPersistentCompositeProps) {
-            throw errors_1.MetadataError.nonPersistentCompositeProp(meta, prop);
+        if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && prop.persist === false && metadata.find(prop.type).compositePK && options.checkNonPersistentCompositeProps) {
+            throw MetadataError.nonPersistentCompositeProp(meta, prop);
         }
     }
     validateBidirectional(meta, prop, metadata) {
@@ -125,67 +122,67 @@ class MetadataValidator {
         }
         else {
             // 1:m property has `mappedBy`
-            if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY && !prop.mappedBy) {
-                throw errors_1.MetadataError.fromMissingOption(meta, prop, 'mappedBy');
+            if (prop.kind === ReferenceKind.ONE_TO_MANY && !prop.mappedBy) {
+                throw MetadataError.fromMissingOption(meta, prop, 'mappedBy');
             }
         }
     }
     validateOwningSide(meta, prop, inverse, metadata) {
         // has correct `inversedBy` on owning side
         if (!inverse) {
-            throw errors_1.MetadataError.fromWrongReference(meta, prop, 'inversedBy');
+            throw MetadataError.fromWrongReference(meta, prop, 'inversedBy');
         }
         const targetClassName = metadata.find(inverse.type)?.root.className;
         // has correct `inversedBy` reference type
         if (inverse.type !== meta.className && targetClassName !== meta.root.className) {
-            throw errors_1.MetadataError.fromWrongReference(meta, prop, 'inversedBy', inverse);
+            throw MetadataError.fromWrongReference(meta, prop, 'inversedBy', inverse);
         }
         // inverse side is not defined as owner
         if (inverse.inversedBy || inverse.owner) {
-            throw errors_1.MetadataError.fromWrongOwnership(meta, prop, 'inversedBy');
+            throw MetadataError.fromWrongOwnership(meta, prop, 'inversedBy');
         }
     }
     validateInverseSide(meta, prop, owner, metadata) {
         // has correct `mappedBy` on inverse side
         if (prop.mappedBy && !owner) {
-            throw errors_1.MetadataError.fromWrongReference(meta, prop, 'mappedBy');
+            throw MetadataError.fromWrongReference(meta, prop, 'mappedBy');
         }
         // has correct `mappedBy` reference type
         if (owner.type !== meta.className && metadata.find(owner.type)?.root.className !== meta.root.className) {
-            throw errors_1.MetadataError.fromWrongReference(meta, prop, 'mappedBy', owner);
+            throw MetadataError.fromWrongReference(meta, prop, 'mappedBy', owner);
         }
         // owning side is not defined as inverse
         if (owner.mappedBy) {
-            throw errors_1.MetadataError.fromWrongOwnership(meta, prop, 'mappedBy');
+            throw MetadataError.fromWrongOwnership(meta, prop, 'mappedBy');
         }
         // owning side is not defined as inverse
         const valid = [
-            { owner: enums_1.ReferenceKind.MANY_TO_ONE, inverse: enums_1.ReferenceKind.ONE_TO_MANY },
-            { owner: enums_1.ReferenceKind.MANY_TO_MANY, inverse: enums_1.ReferenceKind.MANY_TO_MANY },
-            { owner: enums_1.ReferenceKind.ONE_TO_ONE, inverse: enums_1.ReferenceKind.ONE_TO_ONE },
+            { owner: ReferenceKind.MANY_TO_ONE, inverse: ReferenceKind.ONE_TO_MANY },
+            { owner: ReferenceKind.MANY_TO_MANY, inverse: ReferenceKind.MANY_TO_MANY },
+            { owner: ReferenceKind.ONE_TO_ONE, inverse: ReferenceKind.ONE_TO_ONE },
         ];
         if (!valid.find(spec => spec.owner === owner.kind && spec.inverse === prop.kind)) {
-            throw errors_1.MetadataError.fromWrongReferenceKind(meta, owner, prop);
+            throw MetadataError.fromWrongReferenceKind(meta, owner, prop);
         }
         if (prop.primary) {
-            throw errors_1.MetadataError.fromInversideSidePrimary(meta, owner, prop);
+            throw MetadataError.fromInversideSidePrimary(meta, owner, prop);
         }
     }
     validateIndexes(meta, indexes, type) {
         for (const index of indexes) {
-            for (const propName of utils_1.Utils.asArray(index.properties)) {
+            for (const propName of Utils.asArray(index.properties)) {
                 const prop = meta.root.properties[propName];
                 if (!prop && !Object.values(meta.root.properties).some(p => propName.startsWith(p.name + '.'))) {
-                    throw errors_1.MetadataError.unknownIndexProperty(meta, propName, type);
+                    throw MetadataError.unknownIndexProperty(meta, propName, type);
                 }
             }
         }
     }
     validateDuplicateFieldNames(meta, options) {
         const candidates = Object.values(meta.properties)
-            .filter(prop => prop.persist !== false && !prop.inherited && prop.fieldNames?.length === 1 && (prop.kind !== enums_1.ReferenceKind.EMBEDDED || prop.object))
+            .filter(prop => prop.persist !== false && !prop.inherited && prop.fieldNames?.length === 1 && (prop.kind !== ReferenceKind.EMBEDDED || prop.object))
             .map(prop => prop.fieldNames[0]);
-        const duplicates = utils_1.Utils.findDuplicates(candidates);
+        const duplicates = Utils.findDuplicates(candidates);
         if (duplicates.length > 0 && options.checkDuplicateFieldNames) {
             const pairs = duplicates.flatMap(name => {
                 return Object.values(meta.properties)
@@ -194,7 +191,7 @@ class MetadataValidator {
                     return [prop.embedded ? prop.embedded.join('.') : prop.name, prop.fieldNames[0]];
                 });
             });
-            throw errors_1.MetadataError.duplicateFieldName(meta.className, pairs);
+            throw MetadataError.duplicateFieldName(meta.className, pairs);
         }
     }
     validateVersionField(meta) {
@@ -203,13 +200,12 @@ class MetadataValidator {
         }
         const props = Object.values(meta.properties).filter(p => p.version);
         if (props.length > 1) {
-            throw errors_1.MetadataError.multipleVersionFields(meta, props.map(p => p.name));
+            throw MetadataError.multipleVersionFields(meta, props.map(p => p.name));
         }
         const prop = meta.properties[meta.versionProperty];
         const type = prop.runtimeType ?? prop.columnTypes?.[0] ?? prop.type;
         if (type !== 'number' && type !== 'Date' && !type.startsWith('timestamp') && !type.startsWith('datetime')) {
-            throw errors_1.MetadataError.invalidVersionFieldType(meta);
+            throw MetadataError.invalidVersionFieldType(meta);
         }
     }
 }
-exports.MetadataValidator = MetadataValidator;

package/metadata/ReflectMetadataProvider.d.ts

@@ -1,6 +1,6 @@
 import 'reflect-metadata';
-import type { EntityMetadata, EntityProperty } from '../typings';
-import { MetadataProvider } from './MetadataProvider';
+import type { EntityMetadata, EntityProperty } from '../typings.js';
+import { MetadataProvider } from './MetadataProvider.js';
 export declare class ReflectMetadataProvider extends MetadataProvider {
     loadEntityMetadata(meta: EntityMetadata, name: string): void;
     protected initProperties(meta: EntityMetadata): void;

package/metadata/ReflectMetadataProvider.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReflectMetadataProvider = void 0;
-require("reflect-metadata");
-const MetadataProvider_1 = require("./MetadataProvider");
-const enums_1 = require("../enums");
-const Utils_1 = require("../utils/Utils");
-class ReflectMetadataProvider extends MetadataProvider_1.MetadataProvider {
+import 'reflect-metadata';
+import { MetadataProvider } from './MetadataProvider.js';
+import { ReferenceKind } from '../enums.js';
+import { Utils } from '../utils/Utils.js';
+export class ReflectMetadataProvider extends MetadataProvider {
     loadEntityMetadata(meta, name) {
         this.initProperties(meta);
     }
@@ -17,7 +14,7 @@ class ReflectMetadataProvider extends MetadataProvider_1.MetadataProvider {
             }
             else if (prop.entity) {
                 const tmp = prop.entity();
-                prop.type = Array.isArray(tmp) ? tmp.map(t => Utils_1.Utils.className(t)).sort().join(' | ') : Utils_1.Utils.className(tmp);
+                prop.type = Array.isArray(tmp) ? tmp.map(t => Utils.className(t)).sort().join(' | ') : Utils.className(tmp);
             }
             else {
                 this.initPropertyType(meta, prop);
@@ -26,14 +23,14 @@ class ReflectMetadataProvider extends MetadataProvider_1.MetadataProvider {
     }
     initPropertyType(meta, prop) {
         const type = Reflect.getMetadata('design:type', meta.prototype, prop.name);
-        if (!prop.type && (!type || (type === Object && prop.kind !== enums_1.ReferenceKind.SCALAR)) && !(prop.enum && (prop.items?.length ?? 0) > 0)) {
+        if (!prop.type && (!type || (type === Object && prop.kind !== ReferenceKind.SCALAR)) && !(prop.enum && (prop.items?.length ?? 0) > 0)) {
             throw new Error(`Please provide either 'type' or 'entity' attribute in ${meta.className}.${prop.name}. If you are using decorators, ensure you have 'emitDecoratorMetadata' enabled in your tsconfig.json.`);
         }
         // Force mapping to UnknownType which is a string when we see just `Object`, as that often means failed inference.
         // This is to prevent defaulting to JSON column type, which can often be hard to revert and cause hard to understand issues with PKs.
         // If there are explicitly provided `columnTypes`, we use those instead for the inference, this way
         // we can have things like `columnType: 'timestamp'` be respected as `type: 'Date'`.
-        if (prop.kind === enums_1.ReferenceKind.SCALAR && type === Object && !prop.columnTypes) {
+        if (prop.kind === ReferenceKind.SCALAR && type === Object && !prop.columnTypes) {
             prop.type ??= 'any';
             return;
         }
@@ -45,4 +42,3 @@ class ReflectMetadataProvider extends MetadataProvider_1.MetadataProvider {
         prop.runtimeType ??= typeName;
     }
 }
-exports.ReflectMetadataProvider = ReflectMetadataProvider;

package/metadata/index.d.ts

@@ -1,6 +1,6 @@
-export * from './EntitySchema';
-export * from './MetadataDiscovery';
-export * from './MetadataStorage';
-export * from './MetadataProvider';
-export * from './MetadataValidator';
-export * from './ReflectMetadataProvider';
+export * from './EntitySchema.js';
+export * from './MetadataDiscovery.js';
+export * from './MetadataStorage.js';
+export * from './MetadataProvider.js';
+export * from './MetadataValidator.js';
+export * from './ReflectMetadataProvider.js';

package/metadata/index.js

@@ -1,22 +1,6 @@
-"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("./EntitySchema"), exports);
-__exportStar(require("./MetadataDiscovery"), exports);
-__exportStar(require("./MetadataStorage"), exports);
-__exportStar(require("./MetadataProvider"), exports);
-__exportStar(require("./MetadataValidator"), exports);
-__exportStar(require("./ReflectMetadataProvider"), exports);
+export * from './EntitySchema.js';
+export * from './MetadataDiscovery.js';
+export * from './MetadataStorage.js';
+export * from './MetadataProvider.js';
+export * from './MetadataValidator.js';
+export * from './ReflectMetadataProvider.js';

package/naming-strategy/AbstractNamingStrategy.d.ts

@@ -1,5 +1,5 @@
-import type { NamingStrategy } from './NamingStrategy';
-import { type ReferenceKind } from '../enums';
+import type { NamingStrategy } from './NamingStrategy.js';
+import { type ReferenceKind } from '../enums.js';
 export declare abstract class AbstractNamingStrategy implements NamingStrategy {
     getClassName(file: string, separator?: string): string;
     classToMigrationName(timestamp: string, customMigrationName?: string): string;

package/naming-strategy/AbstractNamingStrategy.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractNamingStrategy = void 0;
-const enums_1 = require("../enums");
-const populatePathMembers = Object.values(enums_1.PopulatePath);
-class AbstractNamingStrategy {
+import { PopulatePath } from '../enums.js';
+const populatePathMembers = Object.values(PopulatePath);
+export class AbstractNamingStrategy {
     getClassName(file, separator = '-') {
         const name = file.split('.')[0];
         const ret = name.replace(new RegExp(`(?:${separator})+(\\w)`, 'ug'), (_, p1) => p1.toUpperCase());
@@ -17,7 +14,7 @@ class AbstractNamingStrategy {
         return migrationName;
     }
     indexName(tableName, columns, type) {
-        /* istanbul ignore next */
+        /* v8 ignore next 3 */
         if (tableName.includes('.')) {
             tableName = tableName.substring(tableName.indexOf('.') + 1);
         }
@@ -77,4 +74,3 @@ class AbstractNamingStrategy {
         return entityName[0].toLowerCase() + entityName.substring(1) + suffix;
     }
 }
-exports.AbstractNamingStrategy = AbstractNamingStrategy;

package/naming-strategy/EntityCaseNamingStrategy.d.ts

@@ -1,4 +1,4 @@
-import { AbstractNamingStrategy } from './AbstractNamingStrategy';
+import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
 /**
  * This strategy keeps original entity/property names for table/column.
  */

package/naming-strategy/EntityCaseNamingStrategy.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityCaseNamingStrategy = void 0;
-const AbstractNamingStrategy_1 = require("./AbstractNamingStrategy");
+import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
 /**
  * This strategy keeps original entity/property names for table/column.
  */
-class EntityCaseNamingStrategy extends AbstractNamingStrategy_1.AbstractNamingStrategy {
+export class EntityCaseNamingStrategy extends AbstractNamingStrategy {
     classToTableName(entityName) {
         return entityName;
     }
@@ -29,4 +26,3 @@ class EntityCaseNamingStrategy extends AbstractNamingStrategy_1.AbstractNamingSt
         return 'id';
     }
 }
-exports.EntityCaseNamingStrategy = EntityCaseNamingStrategy;

package/naming-strategy/MongoNamingStrategy.d.ts

@@ -1,4 +1,4 @@
-import { AbstractNamingStrategy } from './AbstractNamingStrategy';
+import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
 export declare class MongoNamingStrategy extends AbstractNamingStrategy {
     classToTableName(entityName: string): string;
     joinColumnName(propertyName: string): string;

package/naming-strategy/MongoNamingStrategy.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoNamingStrategy = void 0;
-const AbstractNamingStrategy_1 = require("./AbstractNamingStrategy");
-class MongoNamingStrategy extends AbstractNamingStrategy_1.AbstractNamingStrategy {
+import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
+export class MongoNamingStrategy extends AbstractNamingStrategy {
     classToTableName(entityName) {
         return entityName.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
     }
@@ -22,4 +19,3 @@ class MongoNamingStrategy extends AbstractNamingStrategy_1.AbstractNamingStrateg
         return '_id';
     }
 }
-exports.MongoNamingStrategy = MongoNamingStrategy;

package/naming-strategy/NamingStrategy.d.ts

@@ -1,4 +1,4 @@
-import type { ReferenceKind } from '../enums';
+import type { ReferenceKind } from '../enums.js';
 export interface NamingStrategy {
     /**
      * Return a name of the class based on its file name

package/naming-strategy/NamingStrategy.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/naming-strategy/UnderscoreNamingStrategy.d.ts

@@ -1,4 +1,4 @@
-import { AbstractNamingStrategy } from './AbstractNamingStrategy';
+import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
 export declare class UnderscoreNamingStrategy extends AbstractNamingStrategy {
     classToTableName(entityName: string): string;
     joinColumnName(propertyName: string): string;

package/naming-strategy/UnderscoreNamingStrategy.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnderscoreNamingStrategy = void 0;
-const AbstractNamingStrategy_1 = require("./AbstractNamingStrategy");
-class UnderscoreNamingStrategy extends AbstractNamingStrategy_1.AbstractNamingStrategy {
+import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
+export class UnderscoreNamingStrategy extends AbstractNamingStrategy {
     classToTableName(entityName) {
         return this.underscore(entityName);
     }
@@ -25,4 +22,3 @@ class UnderscoreNamingStrategy extends AbstractNamingStrategy_1.AbstractNamingSt
         return name.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
     }
 }
-exports.UnderscoreNamingStrategy = UnderscoreNamingStrategy;

package/naming-strategy/index.d.ts

@@ -1,5 +1,5 @@
-export * from './NamingStrategy';
-export * from './AbstractNamingStrategy';
-export * from './MongoNamingStrategy';
-export * from './UnderscoreNamingStrategy';
-export * from './EntityCaseNamingStrategy';
+export * from './NamingStrategy.js';
+export * from './AbstractNamingStrategy.js';
+export * from './MongoNamingStrategy.js';
+export * from './UnderscoreNamingStrategy.js';
+export * from './EntityCaseNamingStrategy.js';