@mikro-orm/core 7.0.0-dev.33 → 7.0.0-dev.331

package/naming-strategy/AbstractNamingStrategy.js

@@ -14,7 +14,7 @@ export class AbstractNamingStrategy {
         return migrationName;
     }
     indexName(tableName, columns, type) {
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (tableName.includes('.')) {
             tableName = tableName.substring(tableName.indexOf('.') + 1);
         }
@@ -34,11 +34,14 @@ export class AbstractNamingStrategy {
      * @inheritDoc
      */
     getEntityName(tableName, schemaName) {
-        const name = tableName.match(/^[^$_\p{ID_Start}]/u) ? `E_${tableName}` : tableName;
-        return this.getClassName(name.replaceAll(/[^\u200C\u200D\p{ID_Continue}]+/ug, r => r.split('').map(c => `$${c.codePointAt(0)}`).join('')), '_');
+        const name = /^[^$_\p{ID_Start}]/u.exec(tableName) ? `E_${tableName}` : tableName;
+        return this.getClassName(name.replaceAll(/[^\u200C\u200D\p{ID_Continue}]+/gu, r => r
+            .split('')
+            .map(c => `$${c.codePointAt(0)}`)
+            .join('')), '_');
     }
     columnNameToProperty(columnName) {
-        const propName = columnName.replace(/[_\- ]+(\w)/ug, (_, p1) => p1.toUpperCase());
+        const propName = columnName.replace(/[_\- ]+(\w)/gu, (_, p1) => p1.toUpperCase());
         if (populatePathMembers.includes(propName.replace(/^\${2,}/u, '$$').replace(/^\$\*$/u, '*'))) {
             return `$${propName}`;
         }
@@ -48,7 +51,13 @@ export class AbstractNamingStrategy {
      * @inheritDoc
      */
     getEnumClassName(columnName, tableName, schemaName) {
-        return this.getEntityName(`${tableName}_${columnName}`, schemaName);
+        return this.getEntityName(tableName ? `${tableName}_${columnName}` : columnName, schemaName);
+    }
+    /**
+     * @inheritDoc
+     */
+    getEnumTypeName(columnName, tableName, schemaName) {
+        return 'T' + this.getEnumClassName(columnName, tableName, schemaName);
     }
     /**
      * @inheritDoc
@@ -73,4 +82,16 @@ export class AbstractNamingStrategy {
         }
         return entityName[0].toLowerCase() + entityName.substring(1) + suffix;
     }
+    /**
+     * @inheritDoc
+     */
+    manyToManyPropertyName(ownerEntityName, targetEntityName, pivotTableName, ownerTableName, schemaName) {
+        return this.columnNameToProperty(pivotTableName.replace(new RegExp('^' + ownerTableName + '_'), ''));
+    }
+    /**
+     * @inheritDoc
+     */
+    discriminatorColumnName(baseName) {
+        return this.propertyToColumnName(baseName + 'Type');
+    }
 }

package/naming-strategy/EntityCaseNamingStrategy.d.ts

@@ -3,10 +3,10 @@ import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
  * This strategy keeps original entity/property names for table/column.
  */
 export declare class EntityCaseNamingStrategy extends AbstractNamingStrategy {
-    classToTableName(entityName: string): string;
+    classToTableName(entityName: string, tableName?: string): string;
     joinColumnName(propertyName: string): string;
-    joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean): string;
-    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string): string;
+    joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean, tableName?: string): string;
+    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string, tableName?: string): string;
     propertyToColumnName(propertyName: string): string;
     referenceColumnName(): string;
 }

package/naming-strategy/EntityCaseNamingStrategy.js

@@ -3,21 +3,22 @@ import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
  * This strategy keeps original entity/property names for table/column.
  */
 export class EntityCaseNamingStrategy extends AbstractNamingStrategy {
-    classToTableName(entityName) {
-        return entityName;
+    classToTableName(entityName, tableName) {
+        return tableName ?? entityName;
     }
     joinColumnName(propertyName) {
         return propertyName;
     }
-    joinKeyColumnName(entityName, referencedColumnName, composite = false) {
-        const name = entityName.substr(0, 1).toLowerCase() + entityName.substr(1);
+    joinKeyColumnName(entityName, referencedColumnName, composite, tableName) {
+        entityName = this.classToTableName(entityName, tableName);
+        const name = entityName.substring(0, 1).toLowerCase() + entityName.substring(1);
         if (composite && referencedColumnName) {
             return name + '_' + referencedColumnName;
         }
         return name;
     }
-    joinTableName(sourceEntity, targetEntity, propertyName) {
-        return this.classToTableName(sourceEntity) + '_' + this.propertyToColumnName(propertyName);
+    joinTableName(sourceEntity, targetEntity, propertyName, tableName) {
+        return this.classToTableName(sourceEntity, tableName) + '_' + this.propertyToColumnName(propertyName);
     }
     propertyToColumnName(propertyName) {
         return propertyName;

package/naming-strategy/MongoNamingStrategy.d.ts

@@ -1,9 +1,9 @@
 import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
 export declare class MongoNamingStrategy extends AbstractNamingStrategy {
-    classToTableName(entityName: string): string;
+    classToTableName(entityName: string, tableName?: string): string;
     joinColumnName(propertyName: string): string;
-    joinKeyColumnName(entityName: string, referencedColumnName?: string): string;
-    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string): string;
+    joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean, tableName?: string): string;
+    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string, tableName?: string): string;
     propertyToColumnName(propertyName: string): string;
     referenceColumnName(): string;
 }

package/naming-strategy/MongoNamingStrategy.js

@@ -1,16 +1,16 @@
 import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
 export class MongoNamingStrategy extends AbstractNamingStrategy {
-    classToTableName(entityName) {
-        return entityName.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+    classToTableName(entityName, tableName) {
+        return tableName ?? entityName.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
     }
     joinColumnName(propertyName) {
         return propertyName;
     }
-    joinKeyColumnName(entityName, referencedColumnName) {
-        return entityName;
+    joinKeyColumnName(entityName, referencedColumnName, composite, tableName) {
+        return tableName ?? entityName;
     }
-    joinTableName(sourceEntity, targetEntity, propertyName) {
-        return this.classToTableName(sourceEntity) + '_' + this.propertyToColumnName(propertyName);
+    joinTableName(sourceEntity, targetEntity, propertyName, tableName) {
+        return this.classToTableName(sourceEntity, tableName) + '_' + this.propertyToColumnName(propertyName);
     }
     propertyToColumnName(propertyName) {
         return propertyName;

package/naming-strategy/NamingStrategy.d.ts

@@ -7,7 +7,7 @@ export interface NamingStrategy {
     /**
      * Return a table name for an entity class
      */
-    classToTableName(entityName: string): string;
+    classToTableName(entityName: string, tableName?: string): string;
     /**
      * Return a migration name. This name should allow ordering.
      */
@@ -25,7 +25,17 @@ export interface NamingStrategy {
      *
      * @return A new class name that will be used for the enum.
      */
-    getEnumClassName(columnName: string, tableName: string, schemaName?: string): string;
+    getEnumClassName(columnName: string, tableName: string | undefined, schemaName?: string): string;
+    /**
+     * Get an enum type name. Used with `enumType: 'dictionary'` and `enumType: 'union-type'` entity generator option.
+     *
+     * @param columnName The column name which has the enum.
+     * @param tableName The table name of the column.
+     * @param schemaName The schema name of the column.
+     *
+     * @return A new type name that will be used for the enum.
+     */
+    getEnumTypeName(columnName: string, tableName: string | undefined, schemaName?: string): string;
     /**
      * Get an enum option name for a given enum value.
      *
@@ -57,11 +67,11 @@ export interface NamingStrategy {
     /**
      * Return a join table name
      */
-    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string): string;
+    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string, tableName?: string): string;
     /**
      * Return the foreign key column name for the given parameters
      */
-    joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean): string;
+    joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean, tableName?: string): string;
     /**
      * Returns key/constraint name for the given type. Some drivers might not support all the types (e.g. mysql and sqlite enforce the PK name).
      */
@@ -75,4 +85,18 @@ export interface NamingStrategy {
      * Returns the name of the inverse side property. Used in the `EntityGenerator` with `bidirectionalRelations` option.
      */
     inverseSideName(entityName: string, propertyName: string, kind: ReferenceKind): string;
+    /**
+     * Return a property name for a many-to-many relation (used in `EntityGenerator`).
+     *
+     * @param ownerEntityName - The owner entity class name
+     * @param targetEntityName - The target entity class name
+     * @param pivotTableName - The pivot table name
+     * @param ownerTableName - The owner table name
+     * @param schemaName - The schema name (if any)
+     */
+    manyToManyPropertyName(ownerEntityName: string, targetEntityName: string, pivotTableName: string, ownerTableName: string, schemaName?: string): string;
+    /**
+     * Returns the discriminator column name for polymorphic relations.
+     */
+    discriminatorColumnName(baseName: string): string;
 }

package/naming-strategy/UnderscoreNamingStrategy.d.ts

@@ -1,9 +1,9 @@
 import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
 export declare class UnderscoreNamingStrategy extends AbstractNamingStrategy {
-    classToTableName(entityName: string): string;
+    classToTableName(entityName: string, tableName?: string): string;
     joinColumnName(propertyName: string): string;
-    joinKeyColumnName(entityName: string, referencedColumnName?: string): string;
-    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string): string;
+    joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean, tableName?: string): string;
+    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string, tableName?: string): string;
     propertyToColumnName(propertyName: string, object?: boolean): string;
     referenceColumnName(): string;
     private underscore;

package/naming-strategy/UnderscoreNamingStrategy.js

@@ -1,16 +1,16 @@
 import { AbstractNamingStrategy } from './AbstractNamingStrategy.js';
 export class UnderscoreNamingStrategy extends AbstractNamingStrategy {
-    classToTableName(entityName) {
-        return this.underscore(entityName);
+    classToTableName(entityName, tableName) {
+        return tableName ?? this.underscore(entityName);
     }
     joinColumnName(propertyName) {
         return this.underscore(propertyName) + '_' + this.referenceColumnName();
     }
-    joinKeyColumnName(entityName, referencedColumnName) {
-        return this.classToTableName(entityName) + '_' + (referencedColumnName || this.referenceColumnName());
+    joinKeyColumnName(entityName, referencedColumnName, composite, tableName) {
+        return this.classToTableName(entityName, tableName) + '_' + (referencedColumnName || this.referenceColumnName());
     }
-    joinTableName(sourceEntity, targetEntity, propertyName) {
-        return this.classToTableName(sourceEntity) + '_' + this.classToTableName(propertyName);
+    joinTableName(sourceEntity, targetEntity, propertyName, tableName) {
+        return this.classToTableName(sourceEntity, tableName) + '_' + this.classToTableName(propertyName);
     }
     propertyToColumnName(propertyName, object) {
         return this.underscore(propertyName);

package/naming-strategy/index.d.ts

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

package/naming-strategy/index.js

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

package/not-supported.d.ts

@@ -0,0 +1,2 @@
+export declare function discoverEntities(): void;
+export declare const fs: {};

package/not-supported.js

@@ -0,0 +1,8 @@
+export function discoverEntities() {
+    throw new Error('Folder-based discovery is not supported in this environment.');
+}
+export const fs = new Proxy({}, {
+    get: () => {
+        throw new Error('File system is not supported in this environment.');
+    },
+});

package/package.json

@@ -1,61 +1,72 @@
 {
   "name": "@mikro-orm/core",
-  "type": "module",
-  "version": "7.0.0-dev.33",
+  "version": "7.0.0-dev.331",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": "./index.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
-  },
-  "funding": "https://github.com/sponsors/b4nan",
   "keywords": [
-    "orm",
+    "data-mapper",
+    "ddd",
+    "entity",
+    "identity-map",
+    "javascript",
+    "js",
+    "mariadb",
+    "mikro-orm",
     "mongo",
     "mongodb",
     "mysql",
-    "mariadb",
+    "orm",
     "postgresql",
     "sqlite",
     "sqlite3",
     "ts",
     "typescript",
-    "js",
-    "javascript",
-    "entity",
-    "ddd",
-    "mikro-orm",
-    "unit-of-work",
-    "data-mapper",
-    "identity-map"
+    "unit-of-work"
   ],
-  "author": "Martin Adámek",
-  "license": "MIT",
+  "homepage": "https://mikro-orm.io",
   "bugs": {
     "url": "https://github.com/mikro-orm/mikro-orm/issues"
   },
-  "homepage": "https://mikro-orm.io",
-  "engines": {
-    "node": ">= 22.11.0"
+  "license": "MIT",
+  "author": "Martin Adámek",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "funding": "https://github.com/sponsors/b4nan",
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./index.js",
+    "./file-discovery": {
+      "node": "./metadata/discover-entities.js",
+      "browser": "./not-supported.js"
+    },
+    "./fs-utils": {
+      "node": "./utils/fs-utils.js",
+      "browser": "./not-supported.js"
+    },
+    "./migrations": "./utils/AbstractMigrator.js",
+    "./schema": "./utils/AbstractSchemaGenerator.js",
+    "./dataloader": "./utils/DataloaderUtils.js"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
-    "build": "yarn clean && yarn compile && yarn copy",
+    "build": "yarn compile && yarn copy",
     "clean": "yarn run -T rimraf ./dist",
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
   },
-  "publishConfig": {
-    "access": "public"
+  "peerDependencies": {
+    "dataloader": "2.2.3"
   },
-  "dependencies": {
-    "dataloader": "2.2.3",
-    "dotenv": "17.2.3",
-    "esprima": "4.0.1",
-    "mikro-orm": "7.0.0-dev.33",
-    "reflect-metadata": "0.2.2",
-    "tinyglobby": "0.2.13"
+  "peerDependenciesMeta": {
+    "dataloader": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">= 22.17.0"
   }
 }

package/platforms/ExceptionConverter.js

@@ -1,6 +1,6 @@
 import { DriverException } from '../exceptions.js';
 export class ExceptionConverter {
-    /* v8 ignore next 3 */
+    /* v8 ignore next */
     convertException(exception) {
         return new DriverException(exception);
     }

package/platforms/Platform.d.ts

@@ -1,7 +1,6 @@
-import { inspect } from 'node:util';
 import { EntityRepository } from '../entity/EntityRepository.js';
 import { type NamingStrategy } from '../naming-strategy/NamingStrategy.js';
-import type { Constructor, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, EntityMetadata, SimpleColumnMeta } from '../typings.js';
+import type { Constructor, EntityMetadata, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, SimpleColumnMeta, FilterQuery, EntityValue, EntityKey } from '../typings.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { Configuration } from '../utils/Configuration.js';
@@ -9,6 +8,7 @@ import type { IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
 import { Type } from '../types/index.js';
 import type { MikroORM } from '../MikroORM.js';
 import type { TransformContext } from '../types/Type.js';
+import { Raw } from '../utils/RawQueryFragment.js';
 export declare const JsonProperty: unique symbol;
 export declare abstract class Platform {
     protected readonly exceptionConverter: ExceptionConverter;
@@ -28,9 +28,9 @@ export declare abstract class Platform {
     supportsNativeEnums(): boolean;
     /** for postgres text enums (default) */
     usesEnumCheckConstraints(): boolean;
+    supportsMaterializedViews(): boolean;
     getSchemaHelper(): unknown;
     indexForeignKeys(): boolean;
-    allowsMultiInsert(): boolean;
     /**
      * Whether or not the driver supports retuning list of created PKs back when multi-inserting
      */
@@ -48,11 +48,6 @@ export declare abstract class Platform {
      * Converts scalar primary key representation to native driver wrapper (e.g. string to mongodb's ObjectId)
      */
     denormalizePrimaryKey(data: IPrimaryKey): IPrimaryKey;
-    /**
-     * Used when serializing via toObject and toJSON methods, allows to use different PK field name (like `id` instead of `_id`)
-     */
-    getSerializedPrimaryKeyField(field: string): string;
-    usesDifferentSerializedPrimaryKey(): boolean;
     /**
      * Returns the SQL specific for the platform to get the current timestamp
      */
@@ -66,12 +61,21 @@ export declare abstract class Platform {
     getDateTypeDeclarationSQL(length?: number): string;
     getTimeTypeDeclarationSQL(length?: number): string;
     getRegExpOperator(val?: unknown, flags?: string): string;
+    mapRegExpCondition(mappedKey: string, value: {
+        $re: string;
+        $flags?: string;
+    }): {
+        sql: string;
+        params: unknown[];
+    };
     getRegExpValue(val: RegExp): {
         $re: string;
         $flags?: string;
     };
     isAllowedTopLevelOperator(operator: string): boolean;
-    quoteVersionValue(value: Date | number, prop: EntityProperty): Date | string | number;
+    convertVersionValue(value: Date | number, prop: EntityProperty): Date | string | number | {
+        $in: (string | number)[];
+    };
     getDefaultVersionLength(): number;
     allowsComparingTuples(): boolean;
     isBigIntProperty(prop: EntityProperty): boolean;
@@ -142,14 +146,22 @@ export declare abstract class Platform {
     getMappedType(type: string): Type<unknown>;
     getDefaultMappedType(type: string): Type<unknown>;
     supportsMultipleCascadePaths(): boolean;
+    /**
+     * Returns true if the platform supports ON UPDATE foreign key rules.
+     * Oracle doesn't support ON UPDATE rules.
+     */
+    supportsOnUpdate(): boolean;
     supportsMultipleStatements(): boolean;
+    supportsUnionWhere(): boolean;
     getArrayDeclarationSQL(): string;
     marshallArray(values: string[]): string;
     unmarshallArray(value: string): string[];
     getBlobDeclarationSQL(): string;
     getJsonDeclarationSQL(): string;
-    getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string;
-    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string;
+    getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string | Raw;
+    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string | Raw;
+    processJsonCondition<T extends object>(o: FilterQuery<T>, value: EntityValue<T>, path: EntityKey<T>[], alias: boolean): FilterQuery<T>;
+    protected getJsonValueType(value: unknown): string;
     getJsonIndexDefinition(index: {
         columnNames: string[];
     }): string[];
@@ -158,10 +170,18 @@ export declare abstract class Platform {
     getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
     convertsJsonAutomatically(): boolean;
     convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
-    convertJsonToJSValue(value: unknown, prop: EntityProperty): unknown;
+    convertJsonToJSValue(value: unknown, context?: TransformContext): unknown;
     convertDateToJSValue(value: string | Date): string;
     convertIntervalToJSValue(value: string): unknown;
     convertIntervalToDatabaseValue(value: unknown): unknown;
+    usesAsKeyword(): boolean;
+    /**
+     * Determines how UUID values are compared in the change set tracking.
+     * Return `'string'` for inline string comparison (fast), or `'any'` for deep comparison via type methods.
+     */
+    compareUuids(): string;
+    convertUuidToJSValue(value: unknown): unknown;
+    convertUuidToDatabaseValue(value: unknown): unknown;
     parseDate(value: string | number): Date;
     getRepositoryClass<T extends object>(): Constructor<EntityRepository<T>>;
     getDefaultCharset(): string;
@@ -195,7 +215,7 @@ export declare abstract class Platform {
     getDefaultPrimaryName(tableName: string, columns: string[]): string;
     supportsCustomPrimaryKeyNames(): boolean;
     isPopulated<T>(key: string, populate: readonly PopulateOptions<T>[] | boolean): boolean;
-    shouldHaveColumn<T>(prop: EntityProperty<T>, populate: readonly PopulateOptions<T>[] | boolean, exclude?: string[], includeFormulas?: boolean): boolean;
+    shouldHaveColumn<T>(prop: EntityProperty<T>, populate: readonly PopulateOptions<T>[] | boolean, exclude?: string[], includeFormulas?: boolean, ignoreInlineEmbeddables?: boolean): boolean;
     /**
      * Currently not supported due to how knex does complex sqlite diffing (always based on current schema)
      */
@@ -227,6 +247,4 @@ export declare abstract class Platform {
      * @internal
      */
     clone(): this;
-    /** @ignore */
-    [inspect.custom](): string;
 }