@mikro-orm/decorators 7.0.0-dev.100

package/legacy/Transactional.js

@@ -0,0 +1,29 @@
+import { TransactionPropagation, RequestContext, TransactionContext } from '@mikro-orm/core';
+import { resolveContextProvider } from '../utils.js';
+/**
+ * This decorator wraps the method with `em.transactional()`, so you can provide `TransactionOptions` just like with `em.transactional()`.
+ * The difference is that you can specify the context in which the transaction begins by providing `context` option,
+ * and if omitted, the transaction will begin in the current context implicitly.
+ * It works on async functions and can be nested with `em.transactional()`.
+ * Unlike `em.transactional()`, this decorator uses `REQUIRED` propagation by default, which means it will join existing transactions.
+ */
+export function Transactional(options = {}) {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        if (originalMethod.constructor.name !== 'AsyncFunction') {
+            throw new Error('@Transactional() should be use with async functions');
+        }
+        descriptor.value = async function (...args) {
+            const { context, contextName, ...txOptions } = options;
+            txOptions.propagation ??= TransactionPropagation.REQUIRED;
+            const em = (await resolveContextProvider(this, context))
+                || TransactionContext.getEntityManager(contextName)
+                || RequestContext.getEntityManager(contextName);
+            if (!em) {
+                throw new Error(`@Transactional() decorator can only be applied to methods of classes with \`orm: MikroORM\` property, \`em: EntityManager\` property, or with a callback parameter like \`@Transactional(() => orm)\` that returns one of those types. The parameter will contain a reference to current \`this\`. Returning an EntityRepository from it is also supported.`);
+            }
+            return em.transactional(() => originalMethod.apply(this, args), txOptions);
+        };
+        return descriptor;
+    };
+}

package/legacy/hooks.d.ts

@@ -0,0 +1,16 @@
+export declare function BeforeCreate(): (target: any, method: string) => void;
+export declare function AfterCreate(): (target: any, method: string) => void;
+export declare function BeforeUpdate(): (target: any, method: string) => void;
+export declare function AfterUpdate(): (target: any, method: string) => void;
+export declare function BeforeUpsert(): (target: any, method: string) => void;
+export declare function AfterUpsert(): (target: any, method: string) => void;
+export declare function OnInit(): (target: any, method: string) => void;
+export declare function OnLoad(): (target: any, method: string) => void;
+/**
+ * Called before deleting entity, but only when providing initialized entity to EM#remove()
+ */
+export declare function BeforeDelete(): (target: any, method: string) => void;
+/**
+ * Called after deleting entity, but only when providing initialized entity to EM#remove()
+ */
+export declare function AfterDelete(): (target: any, method: string) => void;

package/legacy/hooks.js

@@ -0,0 +1,45 @@
+import { EventType } from '@mikro-orm/core';
+import { getMetadataFromDecorator } from '../utils.js';
+function hook(type) {
+    return function (target, method) {
+        const meta = getMetadataFromDecorator(target.constructor);
+        meta.hooks[type] ??= [];
+        meta.hooks[type].push(method);
+    };
+}
+export function BeforeCreate() {
+    return hook(EventType.beforeCreate);
+}
+export function AfterCreate() {
+    return hook(EventType.afterCreate);
+}
+export function BeforeUpdate() {
+    return hook(EventType.beforeUpdate);
+}
+export function AfterUpdate() {
+    return hook(EventType.afterUpdate);
+}
+export function BeforeUpsert() {
+    return hook(EventType.beforeUpsert);
+}
+export function AfterUpsert() {
+    return hook(EventType.afterUpsert);
+}
+export function OnInit() {
+    return hook(EventType.onInit);
+}
+export function OnLoad() {
+    return hook(EventType.onLoad);
+}
+/**
+ * Called before deleting entity, but only when providing initialized entity to EM#remove()
+ */
+export function BeforeDelete() {
+    return hook(EventType.beforeDelete);
+}
+/**
+ * Called after deleting entity, but only when providing initialized entity to EM#remove()
+ */
+export function AfterDelete() {
+    return hook(EventType.afterDelete);
+}

package/legacy/index.d.ts

@@ -0,0 +1,18 @@
+export * from './PrimaryKey.js';
+export * from './Entity.js';
+export * from './OneToOne.js';
+export * from './ManyToOne.js';
+export * from './ManyToMany.js';
+export * from './OneToMany.js';
+export * from './Property.js';
+export * from './Check.js';
+export * from './Enum.js';
+export * from './Formula.js';
+export * from './Indexed.js';
+export * from './Embeddable.js';
+export * from './Embedded.js';
+export * from './Filter.js';
+export * from './CreateRequestContext.js';
+export * from './hooks.js';
+export * from './Transactional.js';
+export * from './ReflectMetadataProvider.js';

package/legacy/index.js

@@ -0,0 +1,18 @@
+export * from './PrimaryKey.js';
+export * from './Entity.js';
+export * from './OneToOne.js';
+export * from './ManyToOne.js';
+export * from './ManyToMany.js';
+export * from './OneToMany.js';
+export * from './Property.js';
+export * from './Check.js';
+export * from './Enum.js';
+export * from './Formula.js';
+export * from './Indexed.js';
+export * from './Embeddable.js';
+export * from './Embedded.js';
+export * from './Filter.js';
+export * from './CreateRequestContext.js';
+export * from './hooks.js';
+export * from './Transactional.js';
+export * from './ReflectMetadataProvider.js';

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@mikro-orm/decorators",
+  "type": "module",
+  "version": "7.0.0-dev.100",
+  "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",
+    "./es": "./es/index.js",
+    "./legacy": "./legacy/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "funding": "https://github.com/sponsors/b4nan",
+  "keywords": [
+    "orm",
+    "mongo",
+    "mongodb",
+    "mysql",
+    "mariadb",
+    "postgresql",
+    "sqlite",
+    "sqlite3",
+    "ts",
+    "typescript",
+    "js",
+    "javascript",
+    "entity",
+    "ddd",
+    "mikro-orm",
+    "unit-of-work",
+    "data-mapper",
+    "identity-map"
+  ],
+  "author": "Martin Adámek",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mikro-orm/mikro-orm/issues"
+  },
+  "homepage": "https://mikro-orm.io",
+  "engines": {
+    "node": ">= 22.17.0"
+  },
+  "scripts": {
+    "build": "yarn clean && 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"
+  },
+  "devDependencies": {
+    "@mikro-orm/core": "^6.6.1"
+  },
+  "peerDependencies": {
+    "@mikro-orm/core": "7.0.0-dev.100",
+    "reflect-metadata": "^0.1.0 || ^0.2.0"
+  },
+  "peerDependenciesMeta": {
+    "reflect-metadata": {
+      "optional": true
+    }
+  }
+}

package/utils.d.ts

@@ -0,0 +1,38 @@
+import { type ReferenceKind, type EntityMetadata, type Dictionary, type MaybePromise, EntityManager, EntityRepository, MikroORM, MetadataStorage } from '@mikro-orm/core';
+/**
+ * The type of context that the user intends to inject.
+ */
+export type ContextProvider<T> = MaybePromise<MikroORM> | ((type: T) => MaybePromise<MikroORM | EntityManager | EntityRepository<any> | {
+    getEntityManager(): EntityManager;
+}>);
+/**
+ * Find `EntityManager` in provided context, or else in instance's `orm` or `em` properties.
+ */
+export declare function resolveContextProvider<T>(caller: T & {
+    orm?: MaybePromise<MikroORM>;
+    em?: MaybePromise<EntityManager>;
+}, provider?: ContextProvider<T>): Promise<EntityManager | undefined>;
+/**
+ * Relation decorators allow using two signatures
+ * - using first parameter as options object
+ * - using all parameters
+ *
+ * This function validates those two ways are not mixed and returns the final options object.
+ * If the second way is used, we always consider the last parameter as options object.
+ * @internal
+ */
+export declare function processDecoratorParameters<T>(params: Dictionary): T;
+/**
+ * Validate there is only one property decorator. This disallows using `@Property()` together with e.g. `@ManyToOne()`
+ * on the same property. One should use only `@ManyToOne()` in such case.
+ * We allow the existence of the property in metadata if the reference type is the same, this should allow things like HMR to work.
+ */
+export declare function validateSingleDecorator(meta: EntityMetadata, propertyName: string, reference: ReferenceKind): void;
+/**
+ * Uses some dark magic to get source path to caller where decorator is used.
+ * Analyzes stack trace of error created inside the function call.
+ */
+export declare function lookupPathFromDecorator(name: string, stack?: string[]): string;
+export declare function getMetadataFromDecorator<T = any>(target: T & Dictionary & {
+    [MetadataStorage.PATH_SYMBOL]?: string;
+}): EntityMetadata<T>;

package/utils.js

@@ -0,0 +1,105 @@
+import { Utils, EntityManager, EntityRepository, MikroORM, MetadataError, MetadataStorage, } from '@mikro-orm/core';
+function getEntityManager(caller, context) {
+    if (context instanceof EntityManager) {
+        return context;
+    }
+    if (context instanceof EntityRepository) {
+        return context.getEntityManager();
+    }
+    if (context instanceof MikroORM) {
+        return context.em;
+    }
+    if (caller.em instanceof EntityManager) {
+        return caller.em;
+    }
+    if (caller.orm instanceof MikroORM) {
+        return caller.orm.em;
+    }
+    return undefined;
+}
+/**
+ * Find `EntityManager` in provided context, or else in instance's `orm` or `em` properties.
+ */
+export async function resolveContextProvider(caller, provider) {
+    const context = typeof provider === 'function' ? await provider(caller) : await provider;
+    return getEntityManager({ orm: await caller.orm, em: await caller.em }, context);
+}
+/**
+ * Relation decorators allow using two signatures
+ * - using first parameter as options object
+ * - using all parameters
+ *
+ * This function validates those two ways are not mixed and returns the final options object.
+ * If the second way is used, we always consider the last parameter as options object.
+ * @internal
+ */
+export function processDecoratorParameters(params) {
+    const keys = Object.keys(params);
+    const values = Object.values(params);
+    if (!Utils.isPlainObject(values[0])) {
+        const lastKey = keys[keys.length - 1];
+        const last = params[lastKey];
+        delete params[lastKey];
+        return { ...last, ...params };
+    }
+    // validate only first parameter is used if its an option object
+    const empty = (v) => v == null || (Utils.isPlainObject(v) && !Utils.hasObjectKeys(v));
+    if (values.slice(1).some(v => !empty(v))) {
+        throw new Error('Mixing first decorator parameter as options object with other parameters is forbidden. ' +
+            'If you want to use the options parameter at first position, provide all options inside it.');
+    }
+    return values[0];
+}
+/**
+ * Validate there is only one property decorator. This disallows using `@Property()` together with e.g. `@ManyToOne()`
+ * on the same property. One should use only `@ManyToOne()` in such case.
+ * We allow the existence of the property in metadata if the reference type is the same, this should allow things like HMR to work.
+ */
+export function validateSingleDecorator(meta, propertyName, reference) {
+    if (meta.properties[propertyName] && meta.properties[propertyName].kind !== reference) {
+        throw MetadataError.multipleDecorators(meta.className, propertyName);
+    }
+}
+/**
+ * Uses some dark magic to get source path to caller where decorator is used.
+ * Analyzes stack trace of error created inside the function call.
+ */
+export function lookupPathFromDecorator(name, stack) {
+    // use some dark magic to get source path to caller
+    stack = stack || new Error().stack.split('\n');
+    // In some situations (e.g. swc 1.3.4+), the presence of a source map can obscure the call to
+    // __decorate(), replacing it with the constructor name. To support these cases we look for
+    // Reflect.decorate() as well. Also when babel is used, we need to check
+    // the `_applyDecoratedDescriptor` method instead.
+    let line = stack.findIndex(line => line.match(/__decorate|Reflect\.decorate|_applyDecoratedDescriptor/));
+    // bun does not have those lines at all, only the DecorateProperty/DecorateConstructor,
+    // but those are also present in node, so we need to check this only if they weren't found.
+    if (line === -1) {
+        // here we handle bun which stack is different from nodejs so we search for reflect-metadata
+        // Different bun versions might have different stack traces. The "last index" works for both 1.2.6 and 1.2.7.
+        const reflectLine = stack.findLastIndex(line => Utils.normalizePath(line).includes('node_modules/reflect-metadata/Reflect.js'));
+        if (reflectLine === -1 || reflectLine + 2 >= stack.length || !stack[reflectLine + 1].includes('bun:wrap')) {
+            return name;
+        }
+        line = reflectLine + 2;
+    }
+    if (stack[line].includes('Reflect.decorate')) {
+        line++;
+    }
+    if (Utils.normalizePath(stack[line]).includes('node_modules/tslib/tslib')) {
+        line++;
+    }
+    try {
+        const re = stack[line].match(/\(.+\)/i) ? /\((.*):\d+:\d+\)/ : /at\s*(.*):\d+:\d+$/;
+        return Utils.normalizePath(stack[line].match(re)[1]);
+    }
+    catch {
+        return name;
+    }
+}
+export function getMetadataFromDecorator(target) {
+    if (!Object.hasOwn(target, MetadataStorage.PATH_SYMBOL)) {
+        Object.defineProperty(target, MetadataStorage.PATH_SYMBOL, { value: lookupPathFromDecorator(target.name), writable: true });
+    }
+    return MetadataStorage.getMetadata(target.name, target[MetadataStorage.PATH_SYMBOL]);
+}