@yandjin-mikro-orm/core 6.1.4-rc-sti-changes-1

package/events/EventManager.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventManager = void 0;
+const utils_1 = require("../utils");
+const enums_1 = require("../enums");
+class EventManager {
+    listeners = {};
+    entities = new Map();
+    cache = new Map();
+    subscribers = [];
+    constructor(subscribers) {
+        subscribers.forEach(subscriber => this.registerSubscriber(subscriber));
+    }
+    registerSubscriber(subscriber) {
+        this.subscribers.push(subscriber);
+        this.entities.set(subscriber, this.getSubscribedEntities(subscriber));
+        this.cache.clear();
+        utils_1.Utils.keys(enums_1.EventType)
+            .filter(event => event in subscriber)
+            .forEach(event => {
+            this.listeners[event] ??= [];
+            this.listeners[event].push(subscriber);
+        });
+    }
+    dispatchEvent(event, args, meta) {
+        const listeners = [];
+        const entity = args.entity;
+        // execute lifecycle hooks first
+        meta ??= entity?.__meta;
+        const hooks = (meta?.hooks[event] || []);
+        listeners.push(...hooks.map(hook => {
+            const prototypeHook = meta?.prototype[hook];
+            const handler = typeof hook === 'function' ? hook : entity[hook] ?? prototypeHook;
+            return handler.bind(entity);
+        }));
+        for (const listener of this.listeners[event] || []) {
+            const entities = this.entities.get(listener);
+            if (entities.length === 0 || !entity || entities.includes(entity.constructor.name)) {
+                listeners.push(listener[event].bind(listener));
+            }
+        }
+        if (event === enums_1.EventType.onInit) {
+            return listeners.forEach(listener => listener(args));
+        }
+        return utils_1.Utils.runSerial(listeners, listener => listener(args));
+    }
+    hasListeners(event, meta) {
+        const cacheKey = meta._id + enums_1.EventTypeMap[event];
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+        const hasHooks = meta.hooks[event]?.length;
+        if (hasHooks) {
+            this.cache.set(cacheKey, true);
+            return true;
+        }
+        for (const listener of this.listeners[event] ?? []) {
+            const entities = this.entities.get(listener);
+            if (entities.length === 0 || entities.includes(meta.className)) {
+                this.cache.set(cacheKey, true);
+                return true;
+            }
+        }
+        this.cache.set(cacheKey, false);
+        return false;
+    }
+    clone() {
+        return new EventManager(this.subscribers);
+    }
+    getSubscribedEntities(listener) {
+        if (!listener.getSubscribedEntities) {
+            return [];
+        }
+        return listener.getSubscribedEntities().map(name => utils_1.Utils.className(name));
+    }
+}
+exports.EventManager = EventManager;

package/events/EventSubscriber.d.ts

@@ -0,0 +1,39 @@
+import type { EntityName, EntityMetadata } from '../typings';
+import type { EntityManager } from '../EntityManager';
+import type { ChangeSet, UnitOfWork } from '../unit-of-work';
+import type { Transaction } from '../connections';
+export interface EventArgs<T> {
+    entity: T;
+    em: EntityManager;
+    meta: EntityMetadata<T>;
+    changeSet?: ChangeSet<T & {}>;
+}
+export interface FlushEventArgs extends Omit<EventArgs<any>, 'entity' | 'changeSet' | 'meta'> {
+    uow: UnitOfWork;
+}
+export interface TransactionEventArgs extends Omit<EventArgs<any>, 'entity' | 'meta' | 'changeSet'> {
+    transaction?: Transaction;
+    uow?: UnitOfWork;
+}
+export interface EventSubscriber<T = any> {
+    getSubscribedEntities?(): EntityName<T>[];
+    onInit?(args: EventArgs<T>): void;
+    onLoad?(args: EventArgs<T>): void | Promise<void>;
+    beforeCreate?(args: EventArgs<T>): void | Promise<void>;
+    afterCreate?(args: EventArgs<T>): void | Promise<void>;
+    beforeUpdate?(args: EventArgs<T>): void | Promise<void>;
+    afterUpdate?(args: EventArgs<T>): void | Promise<void>;
+    beforeUpsert?(args: EventArgs<T>): void | Promise<void>;
+    afterUpsert?(args: EventArgs<T>): void | Promise<void>;
+    beforeDelete?(args: EventArgs<T>): void | Promise<void>;
+    afterDelete?(args: EventArgs<T>): void | Promise<void>;
+    beforeFlush?(args: FlushEventArgs): void | Promise<void>;
+    onFlush?(args: FlushEventArgs): void | Promise<void>;
+    afterFlush?(args: FlushEventArgs): void | Promise<void>;
+    beforeTransactionStart?(args: TransactionEventArgs): void | Promise<void>;
+    afterTransactionStart?(args: TransactionEventArgs): void | Promise<void>;
+    beforeTransactionCommit?(args: TransactionEventArgs): void | Promise<void>;
+    afterTransactionCommit?(args: TransactionEventArgs): void | Promise<void>;
+    beforeTransactionRollback?(args: TransactionEventArgs): void | Promise<void>;
+    afterTransactionRollback?(args: TransactionEventArgs): void | Promise<void>;
+}

package/events/EventSubscriber.js

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

package/events/TransactionEventBroadcaster.d.ts

@@ -0,0 +1,11 @@
+import type { Transaction } from '../connections';
+import type { EntityManager } from '../EntityManager';
+import type { TransactionEventType } from '../enums';
+import type { UnitOfWork } from '../unit-of-work';
+export declare class TransactionEventBroadcaster {
+    private readonly em;
+    private readonly uow?;
+    private readonly eventManager;
+    constructor(em: EntityManager, uow?: UnitOfWork | undefined);
+    dispatchEvent(event: TransactionEventType, transaction?: Transaction): Promise<void>;
+}

package/events/TransactionEventBroadcaster.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionEventBroadcaster = void 0;
+class TransactionEventBroadcaster {
+    em;
+    uow;
+    eventManager;
+    constructor(em, uow) {
+        this.em = em;
+        this.uow = uow;
+        this.eventManager = this.em.getEventManager();
+    }
+    async dispatchEvent(event, transaction) {
+        await this.eventManager.dispatchEvent(event, { em: this.em, transaction, uow: this.uow });
+    }
+}
+exports.TransactionEventBroadcaster = TransactionEventBroadcaster;

package/events/index.d.ts

@@ -0,0 +1,3 @@
+export * from './EventSubscriber';
+export * from './EventManager';
+export * from './TransactionEventBroadcaster';

package/events/index.js

@@ -0,0 +1,19 @@
+"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("./EventSubscriber"), exports);
+__exportStar(require("./EventManager"), exports);
+__exportStar(require("./TransactionEventBroadcaster"), exports);

package/exceptions.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Base class for all errors detected in the driver.
+ */
+export declare class DriverException extends Error {
+    code?: string;
+    errno?: number;
+    sqlState?: string;
+    sqlMessage?: string;
+    errmsg?: string;
+    constructor(previous: Error);
+}
+/**
+ * Base class for all connection related errors detected in the driver.
+ */
+export declare class ConnectionException extends DriverException {
+}
+/**
+ * Base class for all server related errors detected in the driver.
+ */
+export declare class ServerException extends DriverException {
+}
+/**
+ * Base class for all constraint violation related errors detected in the driver.
+ */
+export declare class ConstraintViolationException extends ServerException {
+}
+/**
+ * Base class for all already existing database object related errors detected in the driver.
+ *
+ * A database object is considered any asset that can be created in a database
+ * such as schemas, tables, views, sequences, triggers,  constraints, indexes,
+ * functions, stored procedures etc.
+ */
+export declare class DatabaseObjectExistsException extends ServerException {
+}
+/**
+ * Base class for all unknown database object related errors detected in the driver.
+ *
+ * A database object is considered any asset that can be created in a database
+ * such as schemas, tables, views, sequences, triggers,  constraints, indexes,
+ * functions, stored procedures etc.
+ */
+export declare class DatabaseObjectNotFoundException extends ServerException {
+}
+/**
+ * Exception for a deadlock error of a transaction detected in the driver.
+ */
+export declare class DeadlockException extends ServerException {
+}
+/**
+ * Exception for a foreign key constraint violation detected in the driver.
+ */
+export declare class ForeignKeyConstraintViolationException extends ConstraintViolationException {
+}
+/**
+ * Exception for a check constraint violation detected in the driver.
+ */
+export declare class CheckConstraintViolationException extends ConstraintViolationException {
+}
+/**
+ * Exception for an invalid specified field name in a statement detected in the driver.
+ */
+export declare class InvalidFieldNameException extends ServerException {
+}
+/**
+ * Exception for a lock wait timeout error of a transaction detected in the driver.
+ */
+export declare class LockWaitTimeoutException extends ServerException {
+}
+/**
+ * Exception for a non-unique/ambiguous specified field name in a statement detected in the driver.
+ */
+export declare class NonUniqueFieldNameException extends ServerException {
+}
+/**
+ * Exception for a NOT NULL constraint violation detected in the driver.
+ */
+export declare class NotNullConstraintViolationException extends ConstraintViolationException {
+}
+/**
+ * Exception for a write operation attempt on a read-only database element detected in the driver.
+ */
+export declare class ReadOnlyException extends ServerException {
+}
+/**
+ * Exception for a syntax error in a statement detected in the driver.
+ */
+export declare class SyntaxErrorException extends ServerException {
+}
+/**
+ * Exception for an already existing table referenced in a statement detected in the driver.
+ */
+export declare class TableExistsException extends DatabaseObjectExistsException {
+}
+/**
+ * Exception for an unknown table referenced in a statement detected in the driver.
+ */
+export declare class TableNotFoundException extends DatabaseObjectNotFoundException {
+}
+/**
+ * Exception for a unique constraint violation detected in the driver.
+ */
+export declare class UniqueConstraintViolationException extends ConstraintViolationException {
+}

package/exceptions.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniqueConstraintViolationException = exports.TableNotFoundException = exports.TableExistsException = exports.SyntaxErrorException = exports.ReadOnlyException = exports.NotNullConstraintViolationException = exports.NonUniqueFieldNameException = exports.LockWaitTimeoutException = exports.InvalidFieldNameException = exports.CheckConstraintViolationException = exports.ForeignKeyConstraintViolationException = exports.DeadlockException = exports.DatabaseObjectNotFoundException = exports.DatabaseObjectExistsException = exports.ConstraintViolationException = exports.ServerException = exports.ConnectionException = exports.DriverException = void 0;
+/**
+ * Base class for all errors detected in the driver.
+ */
+class DriverException extends Error {
+    code;
+    errno;
+    sqlState;
+    sqlMessage;
+    errmsg;
+    constructor(previous) {
+        super(previous.message);
+        Object.assign(this, previous);
+        this.name = this.constructor.name;
+        this.stack += '\n\n' + 'previous ' + previous.stack;
+    }
+}
+exports.DriverException = DriverException;
+/**
+ * Base class for all connection related errors detected in the driver.
+ */
+class ConnectionException extends DriverException {
+}
+exports.ConnectionException = ConnectionException;
+/**
+ * Base class for all server related errors detected in the driver.
+ */
+class ServerException extends DriverException {
+}
+exports.ServerException = ServerException;
+/**
+ * Base class for all constraint violation related errors detected in the driver.
+ */
+class ConstraintViolationException extends ServerException {
+}
+exports.ConstraintViolationException = ConstraintViolationException;
+/**
+ * Base class for all already existing database object related errors detected in the driver.
+ *
+ * A database object is considered any asset that can be created in a database
+ * such as schemas, tables, views, sequences, triggers,  constraints, indexes,
+ * functions, stored procedures etc.
+ */
+class DatabaseObjectExistsException extends ServerException {
+}
+exports.DatabaseObjectExistsException = DatabaseObjectExistsException;
+/**
+ * Base class for all unknown database object related errors detected in the driver.
+ *
+ * A database object is considered any asset that can be created in a database
+ * such as schemas, tables, views, sequences, triggers,  constraints, indexes,
+ * functions, stored procedures etc.
+ */
+class DatabaseObjectNotFoundException extends ServerException {
+}
+exports.DatabaseObjectNotFoundException = DatabaseObjectNotFoundException;
+/**
+ * Exception for a deadlock error of a transaction detected in the driver.
+ */
+class DeadlockException extends ServerException {
+}
+exports.DeadlockException = DeadlockException;
+/**
+ * Exception for a foreign key constraint violation detected in the driver.
+ */
+class ForeignKeyConstraintViolationException extends ConstraintViolationException {
+}
+exports.ForeignKeyConstraintViolationException = ForeignKeyConstraintViolationException;
+/**
+ * Exception for a check constraint violation detected in the driver.
+ */
+class CheckConstraintViolationException extends ConstraintViolationException {
+}
+exports.CheckConstraintViolationException = CheckConstraintViolationException;
+/**
+ * Exception for an invalid specified field name in a statement detected in the driver.
+ */
+class InvalidFieldNameException extends ServerException {
+}
+exports.InvalidFieldNameException = InvalidFieldNameException;
+/**
+ * Exception for a lock wait timeout error of a transaction detected in the driver.
+ */
+class LockWaitTimeoutException extends ServerException {
+}
+exports.LockWaitTimeoutException = LockWaitTimeoutException;
+/**
+ * Exception for a non-unique/ambiguous specified field name in a statement detected in the driver.
+ */
+class NonUniqueFieldNameException extends ServerException {
+}
+exports.NonUniqueFieldNameException = NonUniqueFieldNameException;
+/**
+ * Exception for a NOT NULL constraint violation detected in the driver.
+ */
+class NotNullConstraintViolationException extends ConstraintViolationException {
+}
+exports.NotNullConstraintViolationException = NotNullConstraintViolationException;
+/**
+ * Exception for a write operation attempt on a read-only database element detected in the driver.
+ */
+class ReadOnlyException extends ServerException {
+}
+exports.ReadOnlyException = ReadOnlyException;
+/**
+ * Exception for a syntax error in a statement detected in the driver.
+ */
+class SyntaxErrorException extends ServerException {
+}
+exports.SyntaxErrorException = SyntaxErrorException;
+/**
+ * Exception for an already existing table referenced in a statement detected in the driver.
+ */
+class TableExistsException extends DatabaseObjectExistsException {
+}
+exports.TableExistsException = TableExistsException;
+/**
+ * Exception for an unknown table referenced in a statement detected in the driver.
+ */
+class TableNotFoundException extends DatabaseObjectNotFoundException {
+}
+exports.TableNotFoundException = TableNotFoundException;
+/**
+ * Exception for a unique constraint violation detected in the driver.
+ */
+class UniqueConstraintViolationException extends ConstraintViolationException {
+}
+exports.UniqueConstraintViolationException = UniqueConstraintViolationException;

package/hydration/Hydrator.d.ts

@@ -0,0 +1,23 @@
+import type { EntityData, EntityMetadata, EntityProperty, IHydrator } from '../typings';
+import type { EntityFactory } from '../entity/EntityFactory';
+import type { Platform } from '../platforms/Platform';
+import type { MetadataStorage } from '../metadata/MetadataStorage';
+import type { Configuration } from '../utils/Configuration';
+export declare abstract class Hydrator implements IHydrator {
+    protected readonly metadata: MetadataStorage;
+    protected readonly platform: Platform;
+    protected readonly config: Configuration;
+    protected running: boolean;
+    constructor(metadata: MetadataStorage, platform: Platform, config: Configuration);
+    /**
+     * @inheritDoc
+     */
+    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string): void;
+    /**
+     * @inheritDoc
+     */
+    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string): void;
+    isRunning(): boolean;
+    protected getProperties<T extends object>(meta: EntityMetadata<T>, type: 'full' | 'reference'): EntityProperty<T>[];
+    protected hydrateProperty<T extends object>(entity: T, prop: EntityProperty<T>, data: EntityData<T>, factory: EntityFactory, newEntity?: boolean, convertCustomTypes?: boolean): void;
+}

package/hydration/Hydrator.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Hydrator = void 0;
+/* istanbul ignore next */
+class Hydrator {
+    metadata;
+    platform;
+    config;
+    running = false;
+    constructor(metadata, platform, config) {
+        this.metadata = metadata;
+        this.platform = platform;
+        this.config = config;
+    }
+    /**
+     * @inheritDoc
+     */
+    hydrate(entity, meta, data, factory, type, newEntity = false, convertCustomTypes = false, schema) {
+        // the running state is used to consider propagation as hydration, saving the values directly to the entity data,
+        // but we don't want that for new entities, their propagation should result in entity updates when flushing
+        this.running = !newEntity;
+        const props = this.getProperties(meta, type);
+        for (const prop of props) {
+            this.hydrateProperty(entity, prop, data, factory, newEntity, convertCustomTypes);
+        }
+        this.running = false;
+    }
+    /**
+     * @inheritDoc
+     */
+    hydrateReference(entity, meta, data, factory, convertCustomTypes, schema) {
+        this.running = true;
+        meta.primaryKeys.forEach(pk => {
+            this.hydrateProperty(entity, meta.properties[pk], data, factory, false, convertCustomTypes);
+        });
+        this.running = false;
+    }
+    isRunning() {
+        return this.running;
+    }
+    getProperties(meta, type) {
+        if (type === 'reference') {
+            return meta.primaryKeys.map(pk => meta.properties[pk]);
+        }
+        return meta.hydrateProps;
+    }
+    hydrateProperty(entity, prop, data, factory, newEntity, convertCustomTypes) {
+        entity[prop.name] = data[prop.name];
+    }
+}
+exports.Hydrator = Hydrator;

package/hydration/ObjectHydrator.d.ts

@@ -0,0 +1,24 @@
+import type { EntityData, EntityMetadata } from '../typings';
+import { Hydrator } from './Hydrator';
+import type { EntityFactory } from '../entity/EntityFactory';
+type EntityHydrator<T extends object> = (entity: T, data: EntityData<T>, factory: EntityFactory, newEntity: boolean, convertCustomTypes: boolean, schema?: string) => void;
+export declare class ObjectHydrator extends Hydrator {
+    private readonly hydrators;
+    private tmpIndex;
+    /**
+     * @inheritDoc
+     */
+    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string): void;
+    /**
+     * @inheritDoc
+     */
+    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string): void;
+    /**
+     * @internal Highly performance-sensitive method.
+     */
+    getEntityHydrator<T extends object>(meta: EntityMetadata<T>, type: 'full' | 'reference'): EntityHydrator<T>;
+    private createCollectionItemMapper;
+    private wrap;
+    private safeKey;
+}
+export {};