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

package/utils/QueryHelper.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryHelper = void 0;
+const Reference_1 = require("../entity/Reference");
+const Utils_1 = require("./Utils");
+const enums_1 = require("../enums");
+const JsonType_1 = require("../types/JsonType");
+const wrap_1 = require("../entity/wrap");
+class QueryHelper {
+    static SUPPORTED_OPERATORS = ['>', '<', '<=', '>=', '!', '!='];
+    static processParams(params) {
+        if (Reference_1.Reference.isReference(params)) {
+            params = params.unwrap();
+        }
+        if (Utils_1.Utils.isEntity(params)) {
+            if ((0, wrap_1.helper)(params).__meta.compositePK) {
+                return (0, wrap_1.helper)(params).__primaryKeys;
+            }
+            return (0, wrap_1.helper)(params).getPrimaryKey();
+        }
+        if (params === undefined) {
+            return null;
+        }
+        if (Array.isArray(params)) {
+            return params.map(item => QueryHelper.processParams(item));
+        }
+        if (Utils_1.Utils.isPlainObject(params)) {
+            QueryHelper.processObjectParams(params);
+        }
+        return params;
+    }
+    static processObjectParams(params = {}) {
+        Utils_1.Utils.keys(params).forEach(k => {
+            params[k] = QueryHelper.processParams(params[k]);
+        });
+        return params;
+    }
+    static inlinePrimaryKeyObjects(where, meta, metadata, key) {
+        if (Array.isArray(where)) {
+            where.forEach((item, i) => {
+                if (this.inlinePrimaryKeyObjects(item, meta, metadata, key)) {
+                    where[i] = Utils_1.Utils.getPrimaryKeyValues(item, meta.primaryKeys, false);
+                }
+            });
+        }
+        if (!Utils_1.Utils.isPlainObject(where) || (key && meta.properties[key]?.customType instanceof JsonType_1.JsonType)) {
+            return false;
+        }
+        if (meta.primaryKeys.every(pk => pk in where) && Utils_1.Utils.getObjectKeysSize(where) === meta.primaryKeys.length) {
+            return !!key && !enums_1.GroupOperator[key] && Object.keys(where).every(k => !Utils_1.Utils.isPlainObject(where[k]) || Object.keys(where[k]).every(v => {
+                if (Utils_1.Utils.isOperator(v, false)) {
+                    return false;
+                }
+                if (meta.properties[k].primary && [enums_1.ReferenceKind.ONE_TO_ONE, enums_1.ReferenceKind.MANY_TO_ONE].includes(meta.properties[k].kind)) {
+                    return this.inlinePrimaryKeyObjects(where[k], meta.properties[k].targetMeta, metadata, v);
+                }
+                return true;
+            }));
+        }
+        Object.keys(where).forEach(k => {
+            const meta2 = metadata.find(meta.properties[k]?.type) || meta;
+            if (this.inlinePrimaryKeyObjects(where[k], meta2, metadata, k)) {
+                where[k] = Utils_1.Utils.getPrimaryKeyValues(where[k], meta2.primaryKeys, true);
+            }
+        });
+        return false;
+    }
+    static processWhere(options) {
+        // eslint-disable-next-line prefer-const
+        let { where, entityName, metadata, platform, aliased = true, convertCustomTypes = true, root = true } = options;
+        const meta = metadata.find(entityName);
+        // inline PK-only objects in M:N queries, so we don't join the target entity when not needed
+        if (meta && root) {
+            QueryHelper.inlinePrimaryKeyObjects(where, meta, metadata);
+        }
+        if (options.platform.getConfig().get('ignoreUndefinedInQuery') && where && typeof where === 'object') {
+            Utils_1.Utils.dropUndefinedProperties(where);
+        }
+        where = QueryHelper.processParams(where) ?? {};
+        /* istanbul ignore next */
+        if (!root && Utils_1.Utils.isPrimaryKey(where)) {
+            return where;
+        }
+        if (meta && Utils_1.Utils.isPrimaryKey(where, meta.compositePK)) {
+            where = { [Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys)]: where };
+        }
+        if (Array.isArray(where) && root) {
+            const rootPrimaryKey = meta ? Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys) : entityName;
+            let cond = { [rootPrimaryKey]: { $in: where } };
+            // @ts-ignore
+            // detect tuple comparison, use `$or` in case the number of constituents don't match
+            if (meta && !where.every(c => Utils_1.Utils.isPrimaryKey(c) || (Array.isArray(c) && c.length === meta.primaryKeys.length && c.every(i => Utils_1.Utils.isPrimaryKey(i))))) {
+                cond = { $or: where };
+            }
+            return QueryHelper.processWhere({ ...options, where: cond, root: false });
+        }
+        if (!Utils_1.Utils.isPlainObject(where)) {
+            return where;
+        }
+        return Object.keys(where).reduce((o, key) => {
+            let value = where[key];
+            const prop = this.findProperty(key, options);
+            const keys = prop?.joinColumns?.length ?? 0;
+            const composite = keys > 1;
+            if (key in enums_1.GroupOperator) {
+                o[key] = value.map((sub) => QueryHelper.processWhere({ ...options, where: sub, root }));
+                return o;
+            }
+            // wrap top level operators (except platform allowed operators) with PK
+            if (Utils_1.Utils.isOperator(key) && root && meta && !options.platform.isAllowedTopLevelOperator(key)) {
+                const rootPrimaryKey = Utils_1.Utils.getPrimaryKeyHash(meta.primaryKeys);
+                o[rootPrimaryKey] = { [key]: QueryHelper.processWhere({ ...options, where: value, root: false }) };
+                return o;
+            }
+            if (prop?.customType && convertCustomTypes && !platform.isRaw(value)) {
+                value = QueryHelper.processCustomType(prop, value, platform, undefined, true);
+            }
+            const isJsonProperty = prop?.customType instanceof JsonType_1.JsonType && Utils_1.Utils.isPlainObject(value) && !platform.isRaw(value) && Object.keys(value)[0] !== '$eq';
+            if (isJsonProperty) {
+                return this.processJsonCondition(o, value, [prop.fieldNames[0]], platform, aliased);
+            }
+            if (Array.isArray(value) && !Utils_1.Utils.isOperator(key) && !QueryHelper.isSupportedOperator(key) && !key.includes('?') && options.type !== 'orderBy') {
+                if (platform.allowsComparingTuples()) {
+                    // comparing single composite key - use $eq instead of $in
+                    const op = !value.every(v => Array.isArray(v)) && composite ? '$eq' : '$in';
+                    o[key] = { [op]: value };
+                }
+                else {
+                    if (!value.every(v => Array.isArray(v)) && composite) {
+                        o[key] = { $in: [value] };
+                    }
+                    else {
+                        o[key] = { $in: value };
+                    }
+                }
+                return o;
+            }
+            if (Utils_1.Utils.isPlainObject(value)) {
+                o[key] = QueryHelper.processWhere({
+                    ...options,
+                    where: value,
+                    entityName: prop?.type ?? entityName,
+                    root: false,
+                });
+            }
+            else {
+                o[key] = value;
+            }
+            return o;
+        }, {});
+    }
+    static getActiveFilters(entityName, options, filters) {
+        if (options === false) {
+            return [];
+        }
+        const opts = {};
+        if (Array.isArray(options)) {
+            options.forEach(filter => opts[filter] = true);
+        }
+        else if (Utils_1.Utils.isPlainObject(options)) {
+            Object.keys(options).forEach(filter => opts[filter] = options[filter]);
+        }
+        return Object.keys(filters)
+            .filter(f => QueryHelper.isFilterActive(entityName, f, filters[f], opts))
+            .map(f => {
+            filters[f].name = f;
+            return filters[f];
+        });
+    }
+    static isFilterActive(entityName, filterName, filter, options) {
+        if (filter.entity && !filter.entity.includes(entityName)) {
+            return false;
+        }
+        if (options[filterName] === false) {
+            return false;
+        }
+        return filter.default || filterName in options;
+    }
+    static processCustomType(prop, cond, platform, key, fromQuery) {
+        if (Utils_1.Utils.isPlainObject(cond)) {
+            return Utils_1.Utils.keys(cond).reduce((o, k) => {
+                if (Utils_1.Utils.isOperator(k, true) || prop.referencedPKs?.includes(k)) {
+                    o[k] = QueryHelper.processCustomType(prop, cond[k], platform, k, fromQuery);
+                }
+                else {
+                    o[k] = cond[k];
+                }
+                return o;
+            }, {});
+        }
+        if (Array.isArray(cond) && !(key && Utils_1.Utils.isArrayOperator(key))) {
+            return cond.map(v => QueryHelper.processCustomType(prop, v, platform, key, fromQuery));
+        }
+        if (platform.isRaw(cond)) {
+            return cond;
+        }
+        return prop.customType.convertToDatabaseValue(cond, platform, { fromQuery, key, mode: 'query' });
+    }
+    static isSupportedOperator(key) {
+        return !!QueryHelper.SUPPORTED_OPERATORS.find(op => key.includes(op));
+    }
+    static processJsonCondition(o, value, path, platform, alias) {
+        if (Utils_1.Utils.isPlainObject(value) && !Object.keys(value).some(k => Utils_1.Utils.isOperator(k))) {
+            Utils_1.Utils.keys(value).forEach(k => {
+                this.processJsonCondition(o, value[k], [...path, k], platform, alias);
+            });
+            return o;
+        }
+        if (path.length === 1) {
+            o[path[0]] = value;
+            return o;
+        }
+        const operatorObject = Utils_1.Utils.isPlainObject(value) && Object.keys(value).every(k => Utils_1.Utils.isOperator(k));
+        const type = operatorObject ? typeof Object.values(value)[0] : typeof value;
+        const k = platform.getSearchJsonPropertyKey(path, type, alias, value);
+        o[k] = value;
+        return o;
+    }
+    static findProperty(fieldName, options) {
+        const parts = fieldName.split('.');
+        const propName = parts.pop();
+        const alias = parts.length > 0 ? parts.join('.') : undefined;
+        const entityName = alias ? options.aliasMap?.[alias] : options.entityName;
+        const meta = entityName ? options.metadata.find(entityName) : undefined;
+        return meta?.properties[propName];
+    }
+}
+exports.QueryHelper = QueryHelper;

package/utils/RawQueryFragment.d.ts

@@ -0,0 +1,96 @@
+/// <reference types="node" />
+import { inspect } from 'util';
+import type { AnyString, Dictionary, EntityKey } from '../typings';
+export declare class RawQueryFragment {
+    #private;
+    readonly sql: string;
+    readonly params: unknown[];
+    static cloneRegistry?: Set<string>;
+    constructor(sql: string, params?: unknown[]);
+    as(alias: string): RawQueryFragment;
+    valueOf(): string;
+    toJSON(): void;
+    toString(): string;
+    /** @internal */
+    assign(): void;
+    clone(): RawQueryFragment;
+    /**
+     * @internal allows testing we don't leak memory, as the raw fragments cache needs to be cleared automatically
+     */
+    static checkCacheSize(): number;
+    static isKnownFragment(key: string | RawQueryFragment): boolean;
+    static getKnownFragment(key: string | RawQueryFragment, cleanup?: boolean): RawQueryFragment | undefined;
+    static remove(key: string): void;
+    /** @ignore */
+    [inspect.custom](): {
+        sql: string;
+        params: unknown[];
+    } | {
+        sql: string;
+        params?: undefined;
+    };
+}
+/** @internal */
+export declare const ALIAS_REPLACEMENT = "[::alias::]";
+/** @internal */
+export declare const ALIAS_REPLACEMENT_RE = "\\[::alias::\\]";
+/**
+ * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
+ * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
+ * and key. When serialized, the fragment key gets cached and only such cached key will be recognized by the ORM.
+ * This adds a runtime safety to the raw query fragments.
+ *
+ * > **`raw()` helper is required since v6 to use a raw fragment in your query, both through EntityManager and QueryBuilder.**
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: raw('now()') });
+ *
+ * // as a key
+ * await em.find(User, { [raw('lower(name)')]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [raw('(select 1 = 1)')]: [] });
+ * ```
+ *
+ * The `raw` helper supports several signatures, you can pass in a callback that receives the current property alias:
+ *
+ * ```ts
+ * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
+ * ```
+ *
+ * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
+ *
+ * ```ts
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ * ```
+ *
+ * When using inside filters, you might have to use a callback signature to create new raw instance for every filter usage.
+ *
+ * ```ts
+ * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
+ * ```
+ */
+export declare function raw<T extends object = any, R = any>(sql: EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: unknown[] | Dictionary<unknown>): R;
+/**
+ * Alternative to the `raw()` helper allowing to use it as a tagged template function for the simple cases.
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: sql`now()` });
+ *
+ * // as a key
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [sql`(select 1 = 1)`]: [] });
+ * ```
+ */
+export declare function sql(sql: readonly string[], ...values: unknown[]): any;
+export declare namespace sql {
+    var ref: <T extends object>(...keys: string[]) => RawQueryFragment;
+    var now: (length?: number | undefined) => string;
+    var lower: <T extends object>(key: string | ((alias: string) => string)) => string;
+    var upper: <T extends object>(key: string | ((alias: string) => string)) => string;
+}
+export declare function createSqlFunction<T extends object, R = string>(func: string, key: string | ((alias: string) => string)): R;

package/utils/RawQueryFragment.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSqlFunction = exports.sql = exports.raw = exports.ALIAS_REPLACEMENT_RE = exports.ALIAS_REPLACEMENT = exports.RawQueryFragment = void 0;
+const util_1 = require("util");
+const Utils_1 = require("./Utils");
+class RawQueryFragment {
+    sql;
+    params;
+    static #rawQueryCache = new Map();
+    static #index = 0;
+    static cloneRegistry;
+    #assigned = false;
+    #used = 0;
+    #key;
+    constructor(sql, params = []) {
+        this.sql = sql;
+        this.params = params;
+        this.#key = `[raw]: ${this.sql}${this.params ? ` (#${RawQueryFragment.#index++})` : ''}`;
+    }
+    as(alias) {
+        return new RawQueryFragment(`${this.sql} as ${alias}`, this.params);
+    }
+    valueOf() {
+        throw new Error(`Trying to modify raw SQL fragment: '${this.sql}'`);
+    }
+    toJSON() {
+        throw new Error(`Trying to serialize raw SQL fragment: '${this.sql}'`);
+    }
+    toString() {
+        RawQueryFragment.#rawQueryCache.set(this.#key, this);
+        this.#used++;
+        return this.#key;
+    }
+    /** @internal */
+    assign() {
+        if (this.#assigned) {
+            throw new Error(`Cannot reassign already used RawQueryFragment: '${this.sql}'`);
+        }
+        this.#assigned = true;
+    }
+    clone() {
+        RawQueryFragment.cloneRegistry?.add(this.#key);
+        return new RawQueryFragment(this.sql, this.params);
+    }
+    /**
+     * @internal allows testing we don't leak memory, as the raw fragments cache needs to be cleared automatically
+     */
+    static checkCacheSize() {
+        return this.#rawQueryCache.size;
+    }
+    static isKnownFragment(key) {
+        if (key instanceof RawQueryFragment) {
+            return true;
+        }
+        return this.#rawQueryCache.has(key);
+    }
+    static getKnownFragment(key, cleanup = true) {
+        if (key instanceof RawQueryFragment) {
+            return key;
+        }
+        const raw = this.#rawQueryCache.get(key);
+        if (raw && cleanup) {
+            this.remove(key);
+        }
+        return raw;
+    }
+    static remove(key) {
+        const raw = this.#rawQueryCache.get(key);
+        if (!raw) {
+            return;
+        }
+        raw.#used--;
+        if (raw.#used <= 0) {
+            this.#rawQueryCache.delete(key);
+        }
+    }
+    /* istanbul ignore next */
+    /** @ignore */
+    [util_1.inspect.custom]() {
+        if (this.params) {
+            return { sql: this.sql, params: this.params };
+        }
+        return { sql: this.sql };
+    }
+}
+exports.RawQueryFragment = RawQueryFragment;
+Object.defineProperties(RawQueryFragment.prototype, {
+    __raw: { value: true, enumerable: false },
+});
+/** @internal */
+exports.ALIAS_REPLACEMENT = '[::alias::]';
+/** @internal */
+exports.ALIAS_REPLACEMENT_RE = '\\[::alias::\\]';
+/**
+ * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
+ * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
+ * and key. When serialized, the fragment key gets cached and only such cached key will be recognized by the ORM.
+ * This adds a runtime safety to the raw query fragments.
+ *
+ * > **`raw()` helper is required since v6 to use a raw fragment in your query, both through EntityManager and QueryBuilder.**
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: raw('now()') });
+ *
+ * // as a key
+ * await em.find(User, { [raw('lower(name)')]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [raw('(select 1 = 1)')]: [] });
+ * ```
+ *
+ * The `raw` helper supports several signatures, you can pass in a callback that receives the current property alias:
+ *
+ * ```ts
+ * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
+ * ```
+ *
+ * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
+ *
+ * ```ts
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ * ```
+ *
+ * When using inside filters, you might have to use a callback signature to create new raw instance for every filter usage.
+ *
+ * ```ts
+ * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
+ * ```
+ */
+function raw(sql, params) {
+    if (sql instanceof RawQueryFragment) {
+        return sql;
+    }
+    if (sql instanceof Function) {
+        sql = sql(exports.ALIAS_REPLACEMENT);
+    }
+    if (sql === '??' && Array.isArray(params)) {
+        return new RawQueryFragment(sql, params);
+    }
+    if (Array.isArray(sql)) {
+        // for composite FK we return just a simple string
+        return Utils_1.Utils.getPrimaryKeyHash(sql);
+    }
+    if (typeof params === 'object' && !Array.isArray(params)) {
+        const pairs = Object.entries(params);
+        params = [];
+        for (const [key, value] of pairs) {
+            sql = sql.replace(':' + key, '?');
+            params.push(value);
+        }
+    }
+    return new RawQueryFragment(sql, params);
+}
+exports.raw = raw;
+/**
+ * Alternative to the `raw()` helper allowing to use it as a tagged template function for the simple cases.
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: sql`now()` });
+ *
+ * // as a key
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [sql`(select 1 = 1)`]: [] });
+ * ```
+ */
+function sql(sql, ...values) {
+    return raw(sql.reduce((query, queryPart, i) => {
+        const valueExists = i < values.length;
+        const text = query + queryPart;
+        return valueExists ? text + '?' : text;
+    }, ''), values);
+}
+exports.sql = sql;
+function createSqlFunction(func, key) {
+    if (typeof key === 'string') {
+        return raw(`${func}(${key})`);
+    }
+    return raw(a => `${func}(${(key(a))})`);
+}
+exports.createSqlFunction = createSqlFunction;
+sql.ref = (...keys) => raw('??', [keys.join('.')]);
+sql.now = (length) => raw('current_timestamp' + (length == null ? '' : `(${length})`));
+sql.lower = (key) => createSqlFunction('lower', key);
+sql.upper = (key) => createSqlFunction('upper', key);

package/utils/RequestContext.d.ts

@@ -0,0 +1,34 @@
+import type { EntityManager } from '../EntityManager';
+import { type LoggingOptions } from '../logging/Logger';
+/**
+ * Uses `AsyncLocalStorage` to create async context that holds the current EM fork.
+ */
+export declare class RequestContext {
+    readonly map: Map<string, EntityManager>;
+    private static storage;
+    private static counter;
+    readonly id: number;
+    constructor(map: Map<string, EntityManager>);
+    /**
+     * Returns default EntityManager.
+     */
+    get em(): EntityManager | undefined;
+    /**
+     * Creates new RequestContext instance and runs the code inside its domain.
+     * If the handler is async, the return value needs to be awaited.
+     */
+    static create<T>(em: EntityManager | EntityManager[], next: (...args: any[]) => T, options?: CreateContextOptions): T;
+    /**
+     * Returns current RequestContext (if available).
+     */
+    static currentRequestContext(): RequestContext | undefined;
+    /**
+     * Returns current EntityManager (if available).
+     */
+    static getEntityManager(name?: string): EntityManager | undefined;
+    private static createContext;
+}
+export interface CreateContextOptions {
+    schema?: string;
+    loggerContext?: LoggingOptions;
+}

package/utils/RequestContext.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestContext = void 0;
+const async_hooks_1 = require("async_hooks");
+/**
+ * Uses `AsyncLocalStorage` to create async context that holds the current EM fork.
+ */
+class RequestContext {
+    map;
+    static storage = new async_hooks_1.AsyncLocalStorage();
+    static counter = 1;
+    id = RequestContext.counter++;
+    constructor(map) {
+        this.map = map;
+    }
+    /**
+     * Returns default EntityManager.
+     */
+    get em() {
+        return this.map.get('default');
+    }
+    /**
+     * Creates new RequestContext instance and runs the code inside its domain.
+     * If the handler is async, the return value needs to be awaited.
+     */
+    static create(em, next, options = {}) {
+        const ctx = this.createContext(em, options);
+        return this.storage.run(ctx, next);
+    }
+    /**
+     * Returns current RequestContext (if available).
+     */
+    static currentRequestContext() {
+        return this.storage.getStore();
+    }
+    /**
+     * Returns current EntityManager (if available).
+     */
+    static getEntityManager(name = 'default') {
+        const context = RequestContext.currentRequestContext();
+        return context ? context.map.get(name) : undefined;
+    }
+    static createContext(em, options = {}) {
+        const forks = new Map();
+        if (Array.isArray(em)) {
+            em.forEach(em => forks.set(em.name, em.fork({ useContext: true, ...options })));
+        }
+        else {
+            forks.set(em.name, em.fork({ useContext: true, ...options }));
+        }
+        return new RequestContext(forks);
+    }
+}
+exports.RequestContext = RequestContext;

package/utils/TransactionContext.d.ts

@@ -0,0 +1,19 @@
+import type { EntityManager } from '../EntityManager';
+export declare class TransactionContext {
+    readonly em: EntityManager;
+    private static storage;
+    readonly id: number;
+    constructor(em: EntityManager);
+    /**
+     * Creates new TransactionContext instance and runs the code inside its domain.
+     */
+    static create<T>(em: EntityManager, next: (...args: any[]) => T): T;
+    /**
+     * Returns current TransactionContext (if available).
+     */
+    static currentTransactionContext(): TransactionContext | undefined;
+    /**
+     * Returns current EntityManager (if available).
+     */
+    static getEntityManager(name?: string): EntityManager | undefined;
+}

package/utils/TransactionContext.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionContext = void 0;
+const async_hooks_1 = require("async_hooks");
+class TransactionContext {
+    em;
+    static storage = new async_hooks_1.AsyncLocalStorage();
+    id;
+    constructor(em) {
+        this.em = em;
+        this.id = this.em._id;
+    }
+    /**
+     * Creates new TransactionContext instance and runs the code inside its domain.
+     */
+    static create(em, next) {
+        const context = new TransactionContext(em);
+        return this.storage.run(context, next);
+    }
+    /**
+     * Returns current TransactionContext (if available).
+     */
+    static currentTransactionContext() {
+        return this.storage.getStore();
+    }
+    /**
+     * Returns current EntityManager (if available).
+     */
+    static getEntityManager(name = /* istanbul ignore next */ 'default') {
+        const context = TransactionContext.currentTransactionContext();
+        return context?.em.name === name ? context.em : undefined;
+    }
+}
+exports.TransactionContext = TransactionContext;