@mikro-orm/core 7.0.0-rc.1 → 7.0.0-rc.3

package/unit-of-work/ChangeSetComputer.js

@@ -31,7 +31,8 @@ export class ChangeSetComputer {
         const map = new Map();
         // Execute `onCreate` and `onUpdate` on properties recursively, saves `onUpdate` results
         // to the `map` as we want to apply those only if something else changed.
-        if (type === ChangeSetType.CREATE) { // run update hooks only after we know there are other changes
+        if (type === ChangeSetType.CREATE) {
+            // run update hooks only after we know there are other changes
             for (const prop of meta.hydrateProps) {
                 this.processPropertyInitializers(entity, prop, type, map);
             }
@@ -74,10 +75,10 @@ export class ChangeSetComputer {
      * Traverses entity graph and executes `onCreate` and `onUpdate` methods, assigning the values to given properties.
      */
     processPropertyInitializers(entity, prop, type, map, nested) {
-        if (prop.onCreate
-            && type === ChangeSetType.CREATE
-            && (entity[prop.name] == null
-                || (Utils.isScalarReference(entity[prop.name]) && entity[prop.name].unwrap() == null))) {
+        if (prop.onCreate &&
+            type === ChangeSetType.CREATE &&
+            (entity[prop.name] == null ||
+                (Utils.isScalarReference(entity[prop.name]) && entity[prop.name].unwrap() == null))) {
             entity[prop.name] = prop.onCreate(entity, this.em);
         }
         if (prop.onUpdate && type === ChangeSetType.UPDATE) {
@@ -120,7 +121,8 @@ export class ChangeSetComputer {
             targets.forEach(([t]) => this.processProperty(changeSet, prop, t));
             return;
         }
-        if (Utils.isCollection(target)) { // m:n or 1:m
+        if (Utils.isCollection(target)) {
+            // m:n or 1:m
             this.processToMany(prop, changeSet);
         }
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {

package/unit-of-work/ChangeSetPersister.js

@@ -49,7 +49,10 @@ export class ChangeSetPersister {
         // For STI with conflicting fieldNames (renamedFrom properties), we can't batch mixed child types
         const hasSTIConflicts = meta.root.props.some(p => p.renamedFrom);
         const hasMixedTypes = hasSTIConflicts && changeSets.some(cs => cs.meta.class !== meta.class);
-        if (batched && changeSets.length > 1 && !hasMixedTypes && this.config.get('useBatchUpdates', this.platform.usesBatchUpdates())) {
+        if (batched &&
+            changeSets.length > 1 &&
+            !hasMixedTypes &&
+            this.config.get('useBatchUpdates', this.platform.usesBatchUpdates())) {
             return this.persistManagedEntities(meta, changeSets, options);
         }
         for (const changeSet of changeSets) {
@@ -238,7 +241,9 @@ export class ChangeSetPersister {
         // some drivers might be returning bigint PKs as numbers when the number is small enough,
         // but we need to have it as string so comparison works in change set tracking, so instead
         // of using the raw value from db, we convert it back to the db value explicitly
-        value = prop.customType ? prop.customType.convertToDatabaseValue(insertId, this.platform, { mode: 'serialization' }) : value;
+        value = prop.customType
+            ? prop.customType.convertToDatabaseValue(insertId, this.platform, { mode: 'serialization' })
+            : value;
         changeSet.payload[wrapped.__meta.primaryKeys[0]] = value;
         if (wrapped.__identifier && !Array.isArray(wrapped.__identifier)) {
             wrapped.__identifier.setValue(value);
@@ -268,17 +273,19 @@ export class ChangeSetPersister {
         options = this.prepareOptions(meta, options, {
             convertCustomTypes: false,
         });
-        if (meta.concurrencyCheckKeys.size === 0 && (!meta.versionProperty || changeSet.entity[meta.versionProperty] == null)) {
+        if (meta.concurrencyCheckKeys.size === 0 &&
+            (!meta.versionProperty || changeSet.entity[meta.versionProperty] == null)) {
             return this.driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
         }
         if (meta.versionProperty) {
-            cond[meta.versionProperty] = this.platform.quoteVersionValue(changeSet.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
+            cond[meta.versionProperty] = this.platform.convertVersionValue(changeSet.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
         }
         this.checkConcurrencyKeys(meta, changeSet, cond);
         return this.driver.nativeUpdate(changeSet.meta.class, cond, changeSet.payload, options);
     }
     async checkOptimisticLocks(meta, changeSets, options) {
-        if (meta.concurrencyCheckKeys.size === 0 && (!meta.versionProperty || changeSets.every(cs => cs.entity[meta.versionProperty] == null))) {
+        if (meta.concurrencyCheckKeys.size === 0 &&
+            (!meta.versionProperty || changeSets.every(cs => cs.entity[meta.versionProperty] == null))) {
             return;
         }
         // skip entity references as they don't have version values loaded
@@ -287,7 +294,7 @@ export class ChangeSetPersister {
             const cond = Utils.getPrimaryKeyCond(cs.originalEntity, meta.primaryKeys.concat(...meta.concurrencyCheckKeys));
             if (meta.versionProperty) {
                 // @ts-ignore
-                cond[meta.versionProperty] = this.platform.quoteVersionValue(cs.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
+                cond[meta.versionProperty] = this.platform.convertVersionValue(cs.entity[meta.versionProperty], meta.properties[meta.versionProperty]);
             }
             return cond;
         });
@@ -344,9 +351,7 @@ export class ChangeSetPersister {
             });
             // reload generated columns
             if (!this.usesReturningStatement) {
-                meta.props
-                    .filter(prop => prop.generated && !prop.primary)
-                    .forEach(prop => reloadProps.push(prop));
+                meta.props.filter(prop => prop.generated && !prop.primary).forEach(prop => reloadProps.push(prop));
                 reloadProps.push(...returning);
             }
         }
@@ -407,7 +412,7 @@ export class ChangeSetPersister {
             return;
         }
         if (prop.kind === ReferenceKind.MANY_TO_MANY && Array.isArray(value)) {
-            changeSet.payload[prop.name] = value.map(val => val instanceof EntityIdentifier ? val.getValue() : val);
+            changeSet.payload[prop.name] = value.map(val => (val instanceof EntityIdentifier ? val.getValue() : val));
             return;
         }
         if (prop.name in changeSet.payload) {

package/unit-of-work/CommitOrderCalculator.js

@@ -78,11 +78,13 @@ export class CommitOrderCalculator {
         for (const edge of node.dependencies.values()) {
             const target = this.nodes.get(edge.to);
             switch (target.state) {
-                case 2 /* NodeState.VISITED */: break; // Do nothing, since node was already visited
+                case 2 /* NodeState.VISITED */:
+                    break; // Do nothing, since node was already visited
                 case 1 /* NodeState.IN_PROGRESS */:
                     this.visitOpenNode(node, target, edge);
                     break;
-                case 0 /* NodeState.NOT_VISITED */: this.visit(target);
+                case 0 /* NodeState.NOT_VISITED */:
+                    this.visit(target);
             }
         }
         if (node.state !== 2 /* NodeState.VISITED */) {

package/unit-of-work/UnitOfWork.d.ts

@@ -72,7 +72,13 @@ export declare class UnitOfWork {
     getRemoveStack(): Set<AnyEntity>;
     getChangeSets(): ChangeSet<AnyEntity>[];
     getCollectionUpdates(): Collection<AnyEntity>[];
-    getExtraUpdates(): Set<[AnyEntity, string | string[], (AnyEntity | AnyEntity[] | Reference<any> | Collection<any>), ChangeSet<any> | undefined, ChangeSetType]>;
+    getExtraUpdates(): Set<[
+        AnyEntity,
+        string | string[],
+        AnyEntity | AnyEntity[] | Reference<any> | Collection<any>,
+        ChangeSet<any> | undefined,
+        ChangeSetType
+    ]>;
     shouldAutoFlush<T extends object>(meta: EntityMetadata<T>): boolean;
     clearActionsQueue(): void;
     computeChangeSet<T extends object>(entity: T, type?: ChangeSetType): void;

package/unit-of-work/UnitOfWork.js

@@ -76,7 +76,8 @@ export class UnitOfWork {
             if (!prop) {
                 continue;
             }
-            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
+            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) &&
+                Utils.isPlainObject(data[prop.name])) {
                 // Skip polymorphic relations - they use PolymorphicRef wrapper
                 if (!prop.polymorphic) {
                     data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
@@ -86,12 +87,16 @@ export class UnitOfWork {
                 for (const p of prop.targetMeta.props) {
                     /* v8 ignore next */
                     const prefix = prop.prefix === false ? '' : prop.prefix === true ? prop.name + '_' : prop.prefix;
-                    data[prefix + p.name] = data[prop.name][p.name];
+                    data[(prefix + p.name)] = data[prop.name][p.name];
                 }
                 data[prop.name] = Utils.getPrimaryKeyValues(data[prop.name], prop.targetMeta, true);
             }
             if (prop.hydrate === false && prop.customType?.ensureComparable(meta, prop)) {
-                const converted = prop.customType.convertToJSValue(data[key], this.platform, { key, mode: 'hydration', force: true });
+                const converted = prop.customType.convertToJSValue(data[key], this.platform, {
+                    key,
+                    mode: 'hydration',
+                    force: true,
+                });
                 data[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { key, mode: 'hydration' });
             }
             if (forceUndefined) {
@@ -423,7 +428,10 @@ export class UnitOfWork {
                 if (Utils.isCollection(rel)) {
                     rel.removeWithoutPropagation(entity);
                 }
-                else if (rel && (prop.mapToPk ? helper(this.em.getReference(prop.targetMeta.class, rel)).getSerializedPrimaryKey() === serializedPK : rel === entity)) {
+                else if (rel &&
+                    (prop.mapToPk
+                        ? helper(this.em.getReference(prop.targetMeta.class, rel)).getSerializedPrimaryKey() === serializedPK
+                        : rel === entity)) {
                     if (prop.formula) {
                         delete referrer[prop.name];
                     }
@@ -512,7 +520,13 @@ export class UnitOfWork {
         if (!conflicts) {
             return;
         }
-        this.extraUpdates.add([changeSet.entity, props.map(p => p.name), props.map(p => changeSet.entity[p.name]), changeSet, type]);
+        this.extraUpdates.add([
+            changeSet.entity,
+            props.map(p => p.name),
+            props.map(p => changeSet.entity[p.name]),
+            changeSet,
+            type,
+        ]);
         for (const p of props) {
             delete changeSet.entity[p.name];
             delete changeSet.payload[p.name];
@@ -633,7 +647,7 @@ export class UnitOfWork {
         // when changing a unique nullable property (or a 1:1 relation), we can't do it in a single
         // query as it would cause unique constraint violations
         const uniqueProps = changeSet.meta.uniqueProps.filter(prop => {
-            return (prop.nullable || changeSet.type !== ChangeSetType.CREATE);
+            return prop.nullable || changeSet.type !== ChangeSetType.CREATE;
         });
         this.scheduleExtraUpdate(changeSet, uniqueProps);
         return changeSet.type === ChangeSetType.UPDATE && !Utils.hasObjectKeys(changeSet.payload);
@@ -643,25 +657,33 @@ export class UnitOfWork {
         if (!wrapped.__meta.hasUniqueProps) {
             return [];
         }
-        const simpleUniqueHashes = wrapped.__meta.uniqueProps.map(prop => {
+        const simpleUniqueHashes = wrapped.__meta.uniqueProps
+            .map(prop => {
             if (entity[prop.name] != null) {
-                return prop.kind === ReferenceKind.SCALAR || prop.mapToPk ? entity[prop.name] : helper(entity[prop.name]).getSerializedPrimaryKey();
+                return prop.kind === ReferenceKind.SCALAR || prop.mapToPk
+                    ? entity[prop.name]
+                    : helper(entity[prop.name]).getSerializedPrimaryKey();
             }
             if (wrapped.__originalEntityData?.[prop.name] != null) {
                 return Utils.getPrimaryKeyHash(Utils.asArray(wrapped.__originalEntityData[prop.name]));
             }
             return undefined;
-        }).filter(i => i);
-        const compoundUniqueHashes = wrapped.__meta.uniques.map(unique => {
+        })
+            .filter(i => i);
+        const compoundUniqueHashes = wrapped.__meta.uniques
+            .map(unique => {
             const props = Utils.asArray(unique.properties);
             if (props.every(prop => entity[prop] != null)) {
                 return Utils.getPrimaryKeyHash(props.map(p => {
                     const prop = wrapped.__meta.properties[p];
-                    return prop.kind === ReferenceKind.SCALAR || prop.mapToPk ? entity[prop.name] : helper(entity[prop.name]).getSerializedPrimaryKey();
+                    return prop.kind === ReferenceKind.SCALAR || prop.mapToPk
+                        ? entity[prop.name]
+                        : helper(entity[prop.name]).getSerializedPrimaryKey();
                 }));
             }
             return undefined;
-        }).filter(i => i);
+        })
+            .filter(i => i);
         return simpleUniqueHashes.concat(compoundUniqueHashes);
     }
     initIdentifier(entity) {
@@ -693,7 +715,8 @@ export class UnitOfWork {
             return this.processToOneReference(kind, visited, processed, idx);
         }
         if (Utils.isCollection(kind)) {
-            kind.getItems(false)
+            kind
+                .getItems(false)
                 .filter(item => !item.__helper.__originalEntityData)
                 .forEach(item => {
                 // propagate schema from parent
@@ -717,7 +740,8 @@ export class UnitOfWork {
             parent[prop.name] = coll;
             return;
         }
-        collection.getItems(false)
+        collection
+            .getItems(false)
             .filter(item => !item.__helper.__originalEntityData)
             .forEach(item => this.findNewEntities(item, visited, 0, processed));
     }
@@ -809,7 +833,8 @@ export class UnitOfWork {
         return filtered.some(items => processed.has(items));
     }
     shouldCascade(prop, type) {
-        if ([Cascade.REMOVE, Cascade.SCHEDULE_ORPHAN_REMOVAL, Cascade.CANCEL_ORPHAN_REMOVAL, Cascade.ALL].includes(type) && prop.orphanRemoval) {
+        if ([Cascade.REMOVE, Cascade.SCHEDULE_ORPHAN_REMOVAL, Cascade.CANCEL_ORPHAN_REMOVAL, Cascade.ALL].includes(type) &&
+            prop.orphanRemoval) {
             return true;
         }
         // ignore user settings for merge, it is kept only for back compatibility, this should have never been configurable
@@ -845,7 +870,9 @@ export class UnitOfWork {
         const target = Reference.unwrapReference(reference);
         if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && target && !prop.mapToPk) {
             if (!Utils.isEntity(target)) {
-                entity[prop.name] = this.em.getReference(prop.targetMeta.class, target, { wrapped: !!prop.ref });
+                entity[prop.name] = this.em.getReference(prop.targetMeta.class, target, {
+                    wrapped: !!prop.ref,
+                });
             }
             else if (!helper(target).__initialized && !helper(target).__em) {
                 const pk = helper(target).getPrimaryKey();
@@ -907,9 +934,9 @@ export class UnitOfWork {
             return;
         }
         const props = changeSets[0].meta.root.relations.filter(prop => {
-            return (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner)
-                || prop.kind === ReferenceKind.MANY_TO_ONE
-                || (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.platform.usesPivotTable());
+            return ((prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner) ||
+                prop.kind === ReferenceKind.MANY_TO_ONE ||
+                (prop.kind === ReferenceKind.MANY_TO_MANY && prop.owner && !this.platform.usesPivotTable()));
         });
         for (const changeSet of changeSets) {
             this.findExtraUpdates(changeSet, props);
@@ -984,7 +1011,8 @@ export class UnitOfWork {
             wrapped.__originalEntityData = this.comparator.prepareEntity(changeSet.entity);
             if (!wrapped.__initialized) {
                 for (const prop of changeSet.meta.relations) {
-                    if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) && changeSet.entity[prop.name] == null) {
+                    if ([ReferenceKind.MANY_TO_MANY, ReferenceKind.ONE_TO_MANY].includes(prop.kind) &&
+                        changeSet.entity[prop.name] == null) {
                         changeSet.entity[prop.name] = Collection.create(changeSet.entity, prop.name, undefined, wrapped.isInitialized());
                     }
                 }
@@ -1013,7 +1041,7 @@ export class UnitOfWork {
                 continue;
             }
             if (Array.isArray(extraUpdate[1])) {
-                extraUpdate[1].forEach((p, i) => extraUpdate[0][p] = extraUpdate[2][i]);
+                extraUpdate[1].forEach((p, i) => (extraUpdate[0][p] = extraUpdate[2][i]));
             }
             else {
                 extraUpdate[0][extraUpdate[1]] = extraUpdate[2];
@@ -1075,7 +1103,8 @@ export class UnitOfWork {
         };
         const addToGroup = (cs) => {
             // Skip stub TPT changesets with empty payload (e.g. leaf with no own-property changes on UPDATE)
-            if ((cs.type === ChangeSetType.UPDATE || cs.type === ChangeSetType.UPDATE_EARLY) && !Utils.hasObjectKeys(cs.payload)) {
+            if ((cs.type === ChangeSetType.UPDATE || cs.type === ChangeSetType.UPDATE_EARLY) &&
+                !Utils.hasObjectKeys(cs.payload)) {
                 return;
             }
             const group = groups[cs.type];

package/utils/AbstractMigrator.d.ts

@@ -0,0 +1,101 @@
+import type { Constructor, IMigrationGenerator, IMigrationRunner, IMigrator, IMigratorStorage, MaybePromise, Migration, MigrationInfo, MigrationRow, MigratorEvent } from '../typings.js';
+import type { Transaction } from '../connections/Connection.js';
+import type { Configuration, MigrationsOptions } from './Configuration.js';
+import type { EntityManagerType, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
+interface RunnableMigration {
+    name: string;
+    path?: string;
+    up: () => MaybePromise<void>;
+    down: () => MaybePromise<void>;
+}
+type MigrateOptions = {
+    from?: string | number;
+    to?: string | number;
+    migrations?: string[];
+    transaction?: Transaction;
+};
+export declare abstract class AbstractMigrator<D extends IDatabaseDriver> implements IMigrator {
+    protected readonly em: D[typeof EntityManagerType];
+    protected runner: IMigrationRunner;
+    protected storage: IMigratorStorage;
+    protected generator: IMigrationGenerator;
+    protected readonly driver: D;
+    protected readonly config: Configuration;
+    protected readonly options: MigrationsOptions;
+    protected absolutePath: string;
+    protected initialized: boolean;
+    private readonly listeners;
+    constructor(em: D[typeof EntityManagerType]);
+    protected abstract createRunner(): IMigrationRunner;
+    protected abstract createStorage(): IMigratorStorage;
+    protected abstract getDefaultGenerator(): IMigrationGenerator;
+    abstract create(path?: string, blank?: boolean, initial?: boolean, name?: string): Promise<{
+        fileName: string;
+        code: string;
+        diff: {
+            up: string[];
+            down: string[];
+        };
+    }>;
+    abstract checkSchema(): Promise<boolean>;
+    abstract createInitial(path?: string, name?: string, blank?: boolean): Promise<{
+        fileName: string;
+        code: string;
+        diff: {
+            up: string[];
+            down: string[];
+        };
+    }>;
+    /**
+     * @inheritDoc
+     */
+    on(eventName: MigratorEvent, listener: (event: MigrationInfo) => MaybePromise<void>): this;
+    /**
+     * @inheritDoc
+     */
+    off(eventName: MigratorEvent, listener: (event: MigrationInfo) => MaybePromise<void>): this;
+    /**
+     * @inheritDoc
+     */
+    getExecuted(): Promise<MigrationRow[]>;
+    /**
+     * @inheritDoc
+     */
+    getPending(): Promise<MigrationInfo[]>;
+    /**
+     * @inheritDoc
+     */
+    up(options?: string | string[] | MigrateOptions): Promise<MigrationInfo[]>;
+    /**
+     * @inheritDoc
+     */
+    down(options?: string | string[] | Omit<MigrateOptions, 'from'>): Promise<MigrationInfo[]>;
+    abstract getStorage(): IMigratorStorage;
+    protected init(): Promise<void>;
+    protected initServices(): void;
+    protected resolve(params: {
+        name: string;
+        path: string;
+    }): RunnableMigration;
+    protected initialize(MigrationClass: Constructor<Migration>, name: string): RunnableMigration;
+    /**
+     * Checks if `src` folder exists, it so, tries to adjust the migrations and seeders paths automatically to use it.
+     * If there is a `dist` or `build` folder, it will be used for the JS variant (`path` option), while the `src` folder will be
+     * used for the TS variant (`pathTs` option).
+     *
+     * If the default folder exists (e.g. `/migrations`), the config will respect that, so this auto-detection should not
+     * break existing projects, only help with the new ones.
+     */
+    private detectSourceFolder;
+    private registerDefaultListeners;
+    private emit;
+    private discoverMigrations;
+    private executeMigrations;
+    private filterUp;
+    private filterDown;
+    private getMigrationFilename;
+    private prefix;
+    protected runMigrations(method: 'up' | 'down', options?: string | string[] | MigrateOptions): Promise<MigrationInfo[]>;
+    private runInTransaction;
+}
+export {};