@mikro-orm/decorators 7.0.2-dev.8 → 7.0.2

package/legacy/Property.js

@@ -1,29 +1,30 @@
 import { Utils, ReferenceKind } from '@mikro-orm/core';
 import { validateSingleDecorator, getMetadataFromDecorator } from '../utils.js';
+/** Defines a scalar property on an entity (legacy TypeScript decorator). */
 export function Property(options = {}) {
-    return function (target, propertyName) {
-        const meta = getMetadataFromDecorator(target.constructor);
-        const desc = Object.getOwnPropertyDescriptor(target, propertyName) || {};
-        validateSingleDecorator(meta, propertyName, ReferenceKind.SCALAR);
-        const name = options.name || propertyName;
-        if (propertyName !== name && !(desc.value instanceof Function)) {
-            Utils.renameKey(options, 'name', 'fieldName');
-        }
-        options.name = propertyName;
-        const { check, ...opts } = options;
-        const prop = { kind: ReferenceKind.SCALAR, ...opts };
-        prop.getter = !!desc.get;
-        prop.setter = !!desc.set;
-        if (desc.value instanceof Function) {
-            prop.getter = true;
-            prop.persist = false;
-            prop.type = 'method';
-            prop.getterName = propertyName;
-            prop.name = name;
-        }
-        if (check) {
-            meta.checks.push({ property: prop.name, expression: check });
-        }
-        meta.properties[prop.name] = prop;
-    };
+  return function (target, propertyName) {
+    const meta = getMetadataFromDecorator(target.constructor);
+    const desc = Object.getOwnPropertyDescriptor(target, propertyName) || {};
+    validateSingleDecorator(meta, propertyName, ReferenceKind.SCALAR);
+    const name = options.name || propertyName;
+    if (propertyName !== name && !(desc.value instanceof Function)) {
+      Utils.renameKey(options, 'name', 'fieldName');
+    }
+    options.name = propertyName;
+    const { check, ...opts } = options;
+    const prop = { kind: ReferenceKind.SCALAR, ...opts };
+    prop.getter = !!desc.get;
+    prop.setter = !!desc.set;
+    if (desc.value instanceof Function) {
+      prop.getter = true;
+      prop.persist = false;
+      prop.type = 'method';
+      prop.getterName = propertyName;
+      prop.name = name;
+    }
+    if (check) {
+      meta.checks.push({ property: prop.name, expression: check });
+    }
+    meta.properties[prop.name] = prop;
+  };
 }

package/legacy/ReflectMetadataProvider.d.ts

@@ -1,6 +1,7 @@
 import 'reflect-metadata';
 import { type EntityMetadata, type EntityProperty, MetadataProvider } from '@mikro-orm/core';
+/** Metadata provider that uses `reflect-metadata` to infer property types from TypeScript's emitted design:type metadata. */
 export declare class ReflectMetadataProvider extends MetadataProvider {
-    loadEntityMetadata(meta: EntityMetadata): void;
-    protected initPropertyType(meta: EntityMetadata, prop: EntityProperty): void;
+  loadEntityMetadata(meta: EntityMetadata): void;
+  protected initPropertyType(meta: EntityMetadata, prop: EntityProperty): void;
 }

package/legacy/ReflectMetadataProvider.js

@@ -1,49 +1,54 @@
 import 'reflect-metadata';
-import { EntitySchema, MetadataProvider, ReferenceKind, Utils, } from '@mikro-orm/core';
+import { EntitySchema, MetadataProvider, ReferenceKind, Utils } from '@mikro-orm/core';
+/** Metadata provider that uses `reflect-metadata` to infer property types from TypeScript's emitted design:type metadata. */
 export class ReflectMetadataProvider extends MetadataProvider {
-    loadEntityMetadata(meta) {
-        // load types and column names
-        for (const prop of meta.props) {
-            /* v8 ignore next */
-            if (typeof prop.entity === 'string') {
-                throw new Error(`Relation target needs to be an entity class or EntitySchema instance, '${prop.entity}' given instead for ${meta.className}.${prop.name}.`);
-            }
-            else if (prop.entity) {
-                const tmp = prop.entity();
-                prop.type = Array.isArray(tmp)
-                    ? tmp
-                        .map(t => Utils.className(t))
-                        .sort()
-                        .join(' | ')
-                    : Utils.className(tmp);
-                prop.target = tmp instanceof EntitySchema ? tmp.meta.class : tmp;
-            }
-            else {
-                this.initPropertyType(meta, prop);
-            }
-        }
+  loadEntityMetadata(meta) {
+    // load types and column names
+    for (const prop of meta.props) {
+      /* v8 ignore next */
+      if (typeof prop.entity === 'string') {
+        throw new Error(
+          `Relation target needs to be an entity class or EntitySchema instance, '${prop.entity}' given instead for ${meta.className}.${prop.name}.`,
+        );
+      } else if (prop.entity) {
+        const tmp = prop.entity();
+        prop.type = Array.isArray(tmp)
+          ? tmp
+              .map(t => Utils.className(t))
+              .sort()
+              .join(' | ')
+          : Utils.className(tmp);
+        prop.target = EntitySchema.is(tmp) ? tmp.meta.class : tmp;
+      } else {
+        this.initPropertyType(meta, prop);
+      }
     }
-    initPropertyType(meta, prop) {
-        const type = Reflect.getMetadata('design:type', meta.prototype, prop.name);
-        if (!prop.type &&
-            (!type || (type === Object && prop.kind !== ReferenceKind.SCALAR)) &&
-            !(prop.enum && (prop.items?.length ?? 0) > 0)) {
-            throw new Error(`Please provide either 'type' or 'entity' attribute in ${meta.className}.${prop.name}. Make sure you have 'emitDecoratorMetadata' enabled in your tsconfig.json.`);
-        }
-        // Force mapping to UnknownType which is a string when we see just `Object`, as that often means failed inference.
-        // This is to prevent defaulting to JSON column type, which can often be hard to revert and cause hard to understand issues with PKs.
-        // If there are explicitly provided `columnTypes`, we use those instead for the inference, this way
-        // we can have things like `columnType: 'timestamp'` be respected as `type: 'Date'`.
-        if (prop.kind === ReferenceKind.SCALAR && type === Object && !prop.columnTypes) {
-            prop.type ??= 'any';
-            return;
-        }
-        let typeName = type?.name;
-        if (typeName && ['string', 'number', 'boolean', 'array', 'object'].includes(typeName.toLowerCase())) {
-            typeName = typeName.toLowerCase();
-        }
-        prop.type ??= typeName;
-        prop.runtimeType ??= typeName;
-        prop.target = type;
+  }
+  initPropertyType(meta, prop) {
+    const type = Reflect.getMetadata('design:type', meta.prototype, prop.name);
+    if (
+      !prop.type &&
+      (!type || (type === Object && prop.kind !== ReferenceKind.SCALAR)) &&
+      !(prop.enum && (prop.items?.length ?? 0) > 0)
+    ) {
+      throw new Error(
+        `Please provide either 'type' or 'entity' attribute in ${meta.className}.${prop.name}. Make sure you have 'emitDecoratorMetadata' enabled in your tsconfig.json.`,
+      );
     }
+    // Force mapping to UnknownType which is a string when we see just `Object`, as that often means failed inference.
+    // This is to prevent defaulting to JSON column type, which can often be hard to revert and cause hard to understand issues with PKs.
+    // If there are explicitly provided `columnTypes`, we use those instead for the inference, this way
+    // we can have things like `columnType: 'timestamp'` be respected as `type: 'Date'`.
+    if (prop.kind === ReferenceKind.SCALAR && type === Object && !prop.columnTypes) {
+      prop.type ??= 'any';
+      return;
+    }
+    let typeName = type?.name;
+    if (typeName && ['string', 'number', 'boolean', 'array', 'object'].includes(typeName.toLowerCase())) {
+      typeName = typeName.toLowerCase();
+    }
+    prop.type ??= typeName;
+    prop.runtimeType ??= typeName;
+    prop.target = type;
+  }
 }

package/legacy/Transactional.d.ts

@@ -1,8 +1,8 @@
 import { type TransactionOptions } from '@mikro-orm/core';
 import { type ContextProvider } from '../utils.js';
 type TransactionalOptions<T> = TransactionOptions & {
-    context?: ContextProvider<T>;
-    contextName?: string;
+  context?: ContextProvider<T>;
+  contextName?: string;
 };
 /**
  * This decorator wraps the method with `em.transactional()`, so you can provide `TransactionOptions` just like with `em.transactional()`.

package/legacy/Transactional.js

@@ -8,22 +8,25 @@ import { resolveContextProvider } from '../utils.js';
  * 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;
+  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

@@ -1,10 +1,18 @@
+/** Called before a new entity is persisted to the database (legacy TypeScript decorator). */
 export declare function BeforeCreate(): (target: any, method: string) => void;
+/** Called after a new entity has been persisted to the database (legacy TypeScript decorator). */
 export declare function AfterCreate(): (target: any, method: string) => void;
+/** Called before an existing entity is updated in the database (legacy TypeScript decorator). */
 export declare function BeforeUpdate(): (target: any, method: string) => void;
+/** Called after an existing entity has been updated in the database (legacy TypeScript decorator). */
 export declare function AfterUpdate(): (target: any, method: string) => void;
+/** Called before an entity is upserted (legacy TypeScript decorator). */
 export declare function BeforeUpsert(): (target: any, method: string) => void;
+/** Called after an entity has been upserted (legacy TypeScript decorator). */
 export declare function AfterUpsert(): (target: any, method: string) => void;
+/** Called when an entity is instantiated by the EntityManager (legacy TypeScript decorator). */
 export declare function OnInit(): (target: any, method: string) => void;
+/** Called after an entity is loaded from the database (legacy TypeScript decorator). */
 export declare function OnLoad(): (target: any, method: string) => void;
 /**
  * Called before deleting entity, but only when providing initialized entity to EM#remove()

package/legacy/hooks.js

@@ -1,45 +1,53 @@
 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);
-    };
+  return function (target, method) {
+    const meta = getMetadataFromDecorator(target.constructor);
+    meta.hooks[type] ??= [];
+    meta.hooks[type].push(method);
+  };
 }
+/** Called before a new entity is persisted to the database (legacy TypeScript decorator). */
 export function BeforeCreate() {
-    return hook(EventType.beforeCreate);
+  return hook(EventType.beforeCreate);
 }
+/** Called after a new entity has been persisted to the database (legacy TypeScript decorator). */
 export function AfterCreate() {
-    return hook(EventType.afterCreate);
+  return hook(EventType.afterCreate);
 }
+/** Called before an existing entity is updated in the database (legacy TypeScript decorator). */
 export function BeforeUpdate() {
-    return hook(EventType.beforeUpdate);
+  return hook(EventType.beforeUpdate);
 }
+/** Called after an existing entity has been updated in the database (legacy TypeScript decorator). */
 export function AfterUpdate() {
-    return hook(EventType.afterUpdate);
+  return hook(EventType.afterUpdate);
 }
+/** Called before an entity is upserted (legacy TypeScript decorator). */
 export function BeforeUpsert() {
-    return hook(EventType.beforeUpsert);
+  return hook(EventType.beforeUpsert);
 }
+/** Called after an entity has been upserted (legacy TypeScript decorator). */
 export function AfterUpsert() {
-    return hook(EventType.afterUpsert);
+  return hook(EventType.afterUpsert);
 }
+/** Called when an entity is instantiated by the EntityManager (legacy TypeScript decorator). */
 export function OnInit() {
-    return hook(EventType.onInit);
+  return hook(EventType.onInit);
 }
+/** Called after an entity is loaded from the database (legacy TypeScript decorator). */
 export function OnLoad() {
-    return hook(EventType.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);
+  return hook(EventType.beforeDelete);
 }
 /**
  * Called after deleting entity, but only when providing initialized entity to EM#remove()
  */
 export function AfterDelete() {
-    return hook(EventType.afterDelete);
+  return hook(EventType.afterDelete);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/decorators",
-  "version": "7.0.2-dev.8",
+  "version": "7.0.2",
   "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.",
   "keywords": [
     "data-mapper",
@@ -49,10 +49,10 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.1"
+    "@mikro-orm/core": "^7.0.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.2-dev.8",
+    "@mikro-orm/core": "7.0.2",
     "reflect-metadata": "^0.1.0 || ^0.2.0"
   },
   "peerDependenciesMeta": {

package/utils.d.ts

@@ -1,17 +1,36 @@
-import { type Dictionary, EntityManager, type EntityMetadata, EntityRepository, type MaybePromise, MetadataStorage, MikroORM, type ReferenceKind } from '@mikro-orm/core';
+import {
+  type Dictionary,
+  EntityManager,
+  type EntityMetadata,
+  EntityRepository,
+  type MaybePromise,
+  MetadataStorage,
+  MikroORM,
+  type ReferenceKind,
+} 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;
-}>);
+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 & {
+export declare function resolveContextProvider<T>(
+  caller: T & {
     orm?: MaybePromise<MikroORM>;
     em?: MaybePromise<EntityManager>;
-}, provider?: ContextProvider<T>): Promise<EntityManager | undefined>;
+  },
+  provider?: ContextProvider<T>,
+): Promise<EntityManager | undefined>;
 /**
  * Relation decorators allow using two signatures
  * - using first parameter as options object
@@ -33,12 +52,24 @@ export declare function validateSingleDecorator(meta: EntityMetadata, propertyNa
  * We need to use the `Object.hasOwn` here, since the metadata object respects inheritance, and the `properties` object might already
  * exist for some base entity.
  */
-export declare function prepareMetadataContext<T>(context: ClassFieldDecoratorContext<T> | ClassGetterDecoratorContext<T> | ClassSetterDecoratorContext<T> | ClassAccessorDecoratorContext<T> | ClassMethodDecoratorContext<T>, kind?: ReferenceKind): EntityMetadata<T>;
+export declare function prepareMetadataContext<T>(
+  context:
+    | ClassFieldDecoratorContext<T>
+    | ClassGetterDecoratorContext<T>
+    | ClassSetterDecoratorContext<T>
+    | ClassAccessorDecoratorContext<T>
+    | ClassMethodDecoratorContext<T>,
+  kind?: ReferenceKind,
+): EntityMetadata<T>;
 /**
  * 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>;
+/** Retrieves or creates the metadata object for a decorated entity class. */
+export declare function getMetadataFromDecorator<T = any>(
+  target: T &
+    Dictionary & {
+      [MetadataStorage.PATH_SYMBOL]?: string;
+    },
+): EntityMetadata<T>;

package/utils.js

@@ -1,28 +1,28 @@
-import { EntityManager, EntityRepository, MetadataError, MetadataStorage, MikroORM, Utils, } from '@mikro-orm/core';
+import { EntityManager, EntityRepository, MetadataError, MetadataStorage, MikroORM, Utils } 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;
+  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);
+  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
@@ -34,21 +34,23 @@ export async function resolveContextProvider(caller, provider) {
  * @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];
+  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()`
@@ -56,9 +58,9 @@ export function processDecoratorParameters(params) {
  * We allow the existence of the property in metadata if the reference kind is the same, this should allow things like HMR to work.
  */
 export function validateSingleDecorator(meta, propertyName, kind) {
-    if (meta.properties[propertyName] && meta.properties[propertyName].kind !== kind) {
-        throw MetadataError.multipleDecorators(meta.className, propertyName);
-    }
+  if (meta.properties[propertyName] && meta.properties[propertyName].kind !== kind) {
+    throw MetadataError.multipleDecorators(meta.className, propertyName);
+  }
 }
 /**
  * Prepares and returns a metadata context for an entity, ensuring default structure and validating proper usage of a single decorator.
@@ -66,60 +68,64 @@ export function validateSingleDecorator(meta, propertyName, kind) {
  * exist for some base entity.
  */
 export function prepareMetadataContext(context, kind) {
-    const meta = context.metadata;
-    if (!Object.hasOwn(meta, 'properties')) {
-        meta.properties = { ...meta.properties };
-    }
-    if (kind) {
-        validateSingleDecorator(meta, context.name, kind);
-    }
-    return meta;
+  const meta = context.metadata;
+  if (!Object.hasOwn(meta, 'properties')) {
+    meta.properties = { ...meta.properties };
+  }
+  if (kind) {
+    validateSingleDecorator(meta, context.name, kind);
+  }
+  return meta;
 }
 /**
  * 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 => /__decorate|Reflect\.decorate|_applyDecoratedDescriptor/.exec(line));
-    // 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 => line.replace(/\\/g, '/').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++;
-    }
-    // Skip decorator runtime helpers (tslib, @oxc-project/runtime, etc.)
-    while (line < stack.length &&
-        /node_modules\/(tslib\/|@oxc-project\/runtime\/)/.test(stack[line].replace(/\\/g, '/'))) {
-        line++;
-    }
-    try {
-        const re = /\(.+\)/i.exec(stack[line]) ? /\((.*):\d+:\d+\)/ : /at\s*(.*):\d+:\d+$/;
-        return stack[line].match(re)[1];
-    }
-    catch {
-        return name;
-    }
+  // 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 => /__decorate|Reflect\.decorate|_applyDecoratedDescriptor/.exec(line));
+  // 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 =>
+      line.replace(/\\/g, '/').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++;
+  }
+  // Skip decorator runtime helpers (tslib, @oxc-project/runtime, etc.)
+  while (
+    line < stack.length &&
+    /node_modules\/(tslib\/|@oxc-project\/runtime\/)/.test(stack[line].replace(/\\/g, '/'))
+  ) {
+    line++;
+  }
+  try {
+    const re = /\(.+\)/i.exec(stack[line]) ? /\((.*):\d+:\d+\)/ : /at\s*(.*):\d+:\d+$/;
+    return stack[line].match(re)[1];
+  } catch {
+    return name;
+  }
 }
+/** Retrieves or creates the metadata object for a decorated entity class. */
 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]);
+  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]);
 }