@mikro-orm/core 7.0.0-dev.111 → 7.0.0-dev.113

package/EntityManager.d.ts

@@ -154,21 +154,21 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      *     - POJO/entity instance
      *
      * ```ts
-     * const currentCursor = await em.findByCursor(User, {}, {
+     * const currentCursor = await em.findByCursor(User, {
      *   first: 10,
      *   after: previousCursor, // cursor instance
      *   orderBy: { id: 'desc' },
      * });
      *
      * // to fetch next page
-     * const nextCursor = await em.findByCursor(User, {}, {
+     * const nextCursor = await em.findByCursor(User, {
      *   first: 10,
      *   after: currentCursor.endCursor, // opaque string
      *   orderBy: { id: 'desc' },
      * });
      *
      * // to fetch next page
-     * const nextCursor2 = await em.findByCursor(User, {}, {
+     * const nextCursor2 = await em.findByCursor(User, {
      *   first: 10,
      *   after: { id: lastSeenId }, // entity-like POJO
      *   orderBy: { id: 'desc' },
@@ -196,7 +196,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * }
      * ```
      */
-    findByCursor<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never, IncludeCount extends boolean = true>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>): Promise<Cursor<Entity, Hint, Fields, Excludes, IncludeCount>>;
+    findByCursor<Entity extends object, Hint extends string = never, Fields extends string = '*', Excludes extends string = never, IncludeCount extends boolean = true>(entityName: EntityName<Entity>, options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>): Promise<Cursor<Entity, Hint, Fields, Excludes, IncludeCount>>;
     /**
      * Refreshes the persistent state of an entity from the database, overriding any local changes that have not yet been
      * persisted. Returns the same entity instance (same object reference), but re-hydrated. If the entity is no longer

package/EntityManager.js

@@ -489,21 +489,21 @@ export class EntityManager {
      *     - POJO/entity instance
      *
      * ```ts
-     * const currentCursor = await em.findByCursor(User, {}, {
+     * const currentCursor = await em.findByCursor(User, {
      *   first: 10,
      *   after: previousCursor, // cursor instance
      *   orderBy: { id: 'desc' },
      * });
      *
      * // to fetch next page
-     * const nextCursor = await em.findByCursor(User, {}, {
+     * const nextCursor = await em.findByCursor(User, {
      *   first: 10,
      *   after: currentCursor.endCursor, // opaque string
      *   orderBy: { id: 'desc' },
      * });
      *
      * // to fetch next page
-     * const nextCursor2 = await em.findByCursor(User, {}, {
+     * const nextCursor2 = await em.findByCursor(User, {
      *   first: 10,
      *   after: { id: lastSeenId }, // entity-like POJO
      *   orderBy: { id: 'desc' },
@@ -531,16 +531,17 @@ export class EntityManager {
      * }
      * ```
      */
-    async findByCursor(entityName, where, options) {
+    async findByCursor(entityName, options) {
         const em = this.getContext(false);
         entityName = Utils.className(entityName);
         options.overfetch ??= true;
+        options.where ??= {};
         if (Utils.isEmpty(options.orderBy)) {
             throw new Error('Explicit `orderBy` option required');
         }
         const [entities, count] = options.includeCount !== false
-            ? await em.findAndCount(entityName, where, options)
-            : [await em.find(entityName, where, options)];
+            ? await em.findAndCount(entityName, options.where, options)
+            : [await em.find(entityName, options.where, options)];
         return new Cursor(entities, count, options, this.metadata.get(entityName));
     }
     /**

package/drivers/IDatabaseDriver.d.ts

@@ -166,7 +166,7 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
     /** @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, I extends boolean = true> 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<FindAllOptions<T, P, F, E>, 'limit' | 'offset'> {
     includeCount?: I;
 }
 export interface FindOneOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {

package/entity/EntityRepository.d.ts

@@ -80,7 +80,7 @@ export declare class EntityRepository<Entity extends object> {
     /**
      * @inheritDoc EntityManager.findByCursor
      */
-    findByCursor<Hint extends string = never, Fields extends string = '*', Excludes extends string = never, IncludeCount extends boolean = true>(where: FilterQuery<Entity>, options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>): Promise<Cursor<Entity, Hint, Fields, Excludes, IncludeCount>>;
+    findByCursor<Hint extends string = never, Fields extends string = '*', Excludes extends string = never, IncludeCount extends boolean = true>(options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>): Promise<Cursor<Entity, Hint, Fields, Excludes, IncludeCount>>;
     /**
      * Finds all entities of given type. You can pass additional options via the `options` parameter.
      */

package/entity/EntityRepository.js

@@ -90,8 +90,8 @@ export class EntityRepository {
     /**
      * @inheritDoc EntityManager.findByCursor
      */
-    async findByCursor(where, options) {
-        return this.getEntityManager().findByCursor(this.entityName, where, options);
+    async findByCursor(options) {
+        return this.getEntityManager().findByCursor(this.entityName, options);
     }
     /**
      * Finds all entities of given type. You can pass additional options via the `options` parameter.

package/metadata/EntitySchema.js

@@ -21,10 +21,6 @@ export class EntitySchema {
         if (meta.class && !meta.internal) {
             EntitySchema.REGISTRY.set(meta.class, this);
         }
-        if (meta.tableName || meta.collection) {
-            Utils.renameKey(meta, 'tableName', 'collection');
-            meta.tableName = meta.collection;
-        }
         Object.assign(this._meta, { className: meta.name }, meta);
         this._meta.root ??= this._meta;
     }
@@ -197,7 +193,7 @@ export class EntitySchema {
         const tableName = this._meta.collection ?? this._meta.tableName;
         if (tableName?.includes('.') && !this._meta.schema) {
             this._meta.schema = tableName.substring(0, tableName.indexOf('.'));
-            this._meta.collection = tableName.substring(tableName.indexOf('.') + 1);
+            this._meta.tableName = tableName.substring(tableName.indexOf('.') + 1);
         }
         this.initProperties();
         this.initPrimaryKeys();

package/metadata/MetadataDiscovery.js

@@ -296,9 +296,9 @@ export class MetadataDiscovery {
         }
         // if the definition is using EntitySchema we still want it to go through the metadata provider to validate no types are missing
         this.metadataProvider.loadEntityMetadata(meta);
-        if (!meta.collection && meta.name) {
+        if (!meta.tableName && meta.name) {
             const entityName = root.discriminatorColumn ? root.name : meta.name;
-            meta.collection = this.namingStrategy.classToTableName(entityName);
+            meta.tableName = this.namingStrategy.classToTableName(entityName);
         }
         this.metadataProvider.saveToCache(meta);
         meta.root = root;
@@ -404,7 +404,7 @@ export class MetadataDiscovery {
             prop.inverseJoinColumns ??= second.fieldNames;
         }
         if (!prop.pivotTable && prop.owner && this.platform.usesPivotTable()) {
-            prop.pivotTable = this.namingStrategy.joinTableName(meta.tableName, meta2.tableName, prop.name);
+            prop.pivotTable = this.namingStrategy.joinTableName(meta.className, meta2.tableName, prop.name, meta.tableName);
         }
         if (prop.mappedBy) {
             const prop2 = meta2.properties[prop.mappedBy];
@@ -417,13 +417,13 @@ export class MetadataDiscovery {
             prop.inverseJoinColumns = prop2.joinColumns;
         }
         prop.referencedColumnNames ??= Utils.flatten(meta.primaryKeys.map(primaryKey => meta.properties[primaryKey].fieldNames));
-        prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.namingStrategy.joinKeyColumnName(meta.root.className, referencedColumnName, meta.compositePK));
+        prop.joinColumns ??= prop.referencedColumnNames.map(referencedColumnName => this.namingStrategy.joinKeyColumnName(meta.root.className, referencedColumnName, meta.compositePK, meta.root.tableName));
         prop.inverseJoinColumns ??= this.initManyToOneFieldName(prop, meta2.root.className);
     }
     initManyToOneFields(prop) {
         const meta2 = this.metadata.get(prop.type);
         const fieldNames = Utils.flatten(meta2.primaryKeys.map(primaryKey => meta2.properties[primaryKey].fieldNames));
-        Utils.defaultValue(prop, 'referencedTableName', meta2.collection);
+        Utils.defaultValue(prop, 'referencedTableName', meta2.tableName);
         if (!prop.joinColumns) {
             prop.joinColumns = fieldNames.map(fieldName => this.namingStrategy.joinKeyColumnName(prop.name, fieldName, fieldNames.length > 1));
         }
@@ -573,8 +573,8 @@ export class MetadataDiscovery {
         }
         // handle self-referenced m:n with same default field names
         if (meta.className === targetType && prop.joinColumns.every((joinColumn, idx) => joinColumn === prop.inverseJoinColumns[idx])) {
-            prop.joinColumns = prop.referencedColumnNames.map(name => this.namingStrategy.joinKeyColumnName(meta.className + '_1', name, meta.compositePK));
-            prop.inverseJoinColumns = prop.referencedColumnNames.map(name => this.namingStrategy.joinKeyColumnName(meta.className + '_2', name, meta.compositePK));
+            prop.joinColumns = prop.referencedColumnNames.map(name => this.namingStrategy.joinKeyColumnName(meta.tableName + '_1', name, meta.compositePK));
+            prop.inverseJoinColumns = prop.referencedColumnNames.map(name => this.namingStrategy.joinKeyColumnName(meta.tableName + '_2', name, meta.compositePK));
             if (prop.inversedBy) {
                 const prop2 = this.metadata.get(targetType).properties[prop.inversedBy];
                 prop2.inverseJoinColumns = prop.joinColumns;
@@ -916,7 +916,7 @@ export class MetadataDiscovery {
             newProp.inherited = !meta.root.properties[prop.name];
             meta.root.addProperty(newProp);
         });
-        meta.collection = meta.root.collection;
+        meta.tableName = meta.root.tableName;
         meta.root.indexes = Utils.unique([...meta.root.indexes, ...meta.indexes]);
         meta.root.uniques = Utils.unique([...meta.root.uniques, ...meta.uniques]);
         meta.root.checks = Utils.unique([...meta.root.checks, ...meta.checks]);

package/naming-strategy/AbstractNamingStrategy.d.ts

@@ -26,10 +26,10 @@ export declare abstract class AbstractNamingStrategy implements NamingStrategy {
      * @inheritDoc
      */
     inverseSideName(entityName: string, propertyName: string, kind: ReferenceKind): string;
-    abstract classToTableName(entityName: string): string;
+    abstract classToTableName(entityName: string, tableName?: string): string;
     abstract joinColumnName(propertyName: string): string;
-    abstract joinKeyColumnName(entityName: string, referencedColumnName?: string): string;
-    abstract joinTableName(sourceEntity: string, targetEntity: string, propertyName?: string): string;
+    abstract joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean, tableName?: string): string;
+    abstract joinTableName(sourceEntity: string, targetEntity: string, propertyName?: string, tableName?: string): string;
     abstract propertyToColumnName(propertyName: string, object?: boolean): string;
     abstract referenceColumnName(): string;
 }

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) {
+    joinKeyColumnName(entityName, referencedColumnName, composite, tableName) {
+        entityName = this.classToTableName(entityName, tableName);
         const name = entityName.substr(0, 1).toLowerCase() + entityName.substr(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.
      */
@@ -67,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).
      */

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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.111",
+  "version": "7.0.0-dev.113",
   "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",

package/utils/Utils.js

@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.111';
+    static #ORM_VERSION = '7.0.0-dev.113';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */