@mikro-orm/core 7.0.2-dev.1 → 7.0.2-dev.11

package/metadata/EntitySchema.d.ts

@@ -54,6 +54,12 @@ export declare class EntitySchema<Entity = any, Base = never, Class extends Enti
     private internal;
     private initialized;
     constructor(meta: EntitySchemaMetadata<Entity, Base, Class>);
+    /**
+     * Checks if the given value is an EntitySchema instance, using duck-typing
+     * as a fallback when `instanceof` fails due to CJS/ESM dual-package hazard
+     * (e.g. when using `tsx` or `@swc-node/register` with `"type": "commonjs"` projects).
+     */
+    static is(item: unknown): item is EntitySchema;
     static fromMetadata<T = AnyEntity, U = never>(meta: EntityMetadata<T> | DeepPartial<EntityMetadata<T>>): EntitySchema<T, U>;
     addProperty(name: EntityKey<Entity>, type?: TypeType, options?: PropertyOptions<Entity> | EntityProperty<Entity>): void;
     addEnum(name: EntityKey<Entity>, type?: TypeType, options?: EnumOptions<Entity>): void;

package/metadata/EntitySchema.js

@@ -27,6 +27,17 @@ export class EntitySchema {
             EntitySchema.REGISTRY.set(meta.class, this);
         }
     }
+    /**
+     * Checks if the given value is an EntitySchema instance, using duck-typing
+     * as a fallback when `instanceof` fails due to CJS/ESM dual-package hazard
+     * (e.g. when using `tsx` or `@swc-node/register` with `"type": "commonjs"` projects).
+     */
+    static is(item) {
+        if (item instanceof EntitySchema) {
+            return true;
+        }
+        return item != null && typeof item === 'object' && item.constructor?.name === 'EntitySchema' && 'meta' in item;
+    }
     static fromMetadata(meta) {
         const schema = new EntitySchema({ ...meta, internal: true });
         schema.internal = true;
@@ -230,7 +241,7 @@ export class EntitySchema {
     isPartOfTPTHierarchy() {
         let parent = this._meta.extends;
         while (parent) {
-            const parentSchema = parent instanceof EntitySchema ? parent : EntitySchema.REGISTRY.get(parent);
+            const parentSchema = EntitySchema.is(parent) ? parent : EntitySchema.REGISTRY.get(parent);
             if (!parentSchema) {
                 break;
             }
@@ -310,7 +321,7 @@ export class EntitySchema {
                         .sort()
                         .join(' | ')
                     : Utils.className(tmp);
-                const target = tmp instanceof EntitySchema ? tmp.meta.class : tmp;
+                const target = EntitySchema.is(tmp) ? tmp.meta.class : tmp;
                 return { type, target };
             }
         }

package/metadata/MetadataDiscovery.js

@@ -228,7 +228,7 @@ export class MetadataDiscovery {
     }
     tryDiscoverTargets(targets) {
         for (const target of targets) {
-            const schema = target instanceof EntitySchema ? target : undefined;
+            const schema = EntitySchema.is(target) ? target : undefined;
             const isDiscoverable = typeof target === 'function' || schema;
             if (isDiscoverable && target.name) {
                 // Get the actual class for EntitySchema, or use target directly for classes
@@ -254,7 +254,7 @@ export class MetadataDiscovery {
         // discover parents (base entities) automatically
         for (const meta of this.#metadata) {
             let parent = meta.extends;
-            if (parent instanceof EntitySchema && !this.#metadata.has(parent.init().meta.class)) {
+            if (EntitySchema.is(parent) && !this.#metadata.has(parent.init().meta.class)) {
                 this.discoverReferences([parent], false);
             }
             if (typeof parent === 'function' && parent.name && !this.#metadata.has(parent)) {
@@ -293,21 +293,23 @@ export class MetadataDiscovery {
         if (EntitySchema.REGISTRY.has(entity)) {
             entity = EntitySchema.REGISTRY.get(entity);
         }
-        if (entity instanceof EntitySchema) {
+        if (EntitySchema.is(entity)) {
             const meta = Utils.copy(entity.meta, false);
             return EntitySchema.fromMetadata(meta);
         }
-        const path = entity[MetadataStorage.PATH_SYMBOL];
+        // After the EntitySchema check, entity must be an EntityClass
+        const cls = entity;
+        const path = cls[MetadataStorage.PATH_SYMBOL];
         if (path) {
-            const meta = Utils.copy(MetadataStorage.getMetadata(entity.name, path), false);
+            const meta = Utils.copy(MetadataStorage.getMetadata(cls.name, path), false);
             meta.path = path;
-            this.#metadata.set(entity, meta);
+            this.#metadata.set(cls, meta);
         }
-        const exists = this.#metadata.has(entity);
-        const meta = this.#metadata.get(entity, true);
+        const exists = this.#metadata.has(cls);
+        const meta = this.#metadata.get(cls, true);
         meta.abstract ??= !(exists && meta.name);
         const schema = EntitySchema.fromMetadata(meta);
-        schema.setClass(entity);
+        schema.setClass(cls);
         return schema;
     }
     getRootEntity(meta) {
@@ -1435,7 +1437,7 @@ export class MetadataDiscovery {
         }
         return metadata.find(m => {
             const ext = meta.extends;
-            if (ext instanceof EntitySchema) {
+            if (EntitySchema.is(ext)) {
                 return m.class === ext.meta.class || m.className === ext.meta.className;
             }
             return m.class === ext || m.className === Utils.className(ext);
@@ -1610,8 +1612,9 @@ export class MetadataDiscovery {
             !prop.customType) {
             // if the type is an ORM defined mapped type without `ensureComparable: true`,
             // we use just the type name, to have more performant hydration code
+            const brand = Type.getOrmType(prop.type);
             const type = Utils.keys(t).find(type => {
-                return !Type.getType(t[type]).ensureComparable(meta, prop) && prop.type === t[type];
+                return (!Type.getType(t[type]).ensureComparable(meta, prop) && (prop.type === t[type] || brand === type));
             });
             if (type) {
                 prop.type = type === 'datetime' ? 'Date' : type;

package/metadata/MetadataProvider.js

@@ -19,7 +19,7 @@ export class MetadataProvider {
                         .sort()
                         .join(' | ')
                     : Utils.className(tmp);
-                prop.target = tmp instanceof EntitySchema ? tmp.meta.class : tmp;
+                prop.target = EntitySchema.is(tmp) ? tmp.meta.class : tmp;
             }
             else if (!prop.type && !((prop.enum || prop.array) && (prop.items?.length ?? 0) > 0)) {
                 throw new Error(`Please provide either 'type' or 'entity' attribute in ${meta.className}.${prop.name}.`);

package/metadata/MetadataStorage.js

@@ -65,7 +65,7 @@ export class MetadataStorage {
         if (meta) {
             return meta;
         }
-        if (entityName instanceof EntitySchema) {
+        if (EntitySchema.is(entityName)) {
             return this.#metadataMap.get(entityName.meta.class) ?? entityName.meta;
         }
         return this.#classNameMap[Utils.className(entityName)];

package/metadata/discover-entities.js

@@ -9,7 +9,7 @@ async function getEntityClassOrSchema(filepath, allTargets, baseDir) {
     const targets = Object.values(exports);
     // ignore class implementations that are linked from an EntitySchema
     for (const item of targets) {
-        if (item instanceof EntitySchema) {
+        if (EntitySchema.is(item)) {
             for (const item2 of targets) {
                 if (item.meta.class === item2) {
                     targets.splice(targets.indexOf(item2), 1);
@@ -18,7 +18,7 @@ async function getEntityClassOrSchema(filepath, allTargets, baseDir) {
         }
     }
     for (const item of targets) {
-        const validTarget = item instanceof EntitySchema || (item instanceof Function && MetadataStorage.isKnownEntity(item.name));
+        const validTarget = EntitySchema.is(item) || (item instanceof Function && MetadataStorage.isKnownEntity(item.name));
         if (validTarget && !allTargets.has(item)) {
             allTargets.set(item, path);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.2-dev.1",
+  "version": "7.0.2-dev.11",
   "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",

package/types/Type.d.ts

@@ -1,5 +1,7 @@
 import type { Platform } from '../platforms/Platform.js';
 import type { Constructor, EntityMetadata, EntityProperty } from '../typings.js';
+/** @internal */
+export declare const ORM_TYPE: unique symbol;
 export interface TransformContext {
     fromQuery?: boolean;
     force?: boolean;
@@ -78,4 +80,10 @@ export declare abstract class Type<JSType = string, DBType = JSType> {
      * Checks whether the argument is instance of `Type`.
      */
     static isMappedType(data: any): data is Type<any>;
+    /**
+     * @internal
+     * Returns the built-in type registry key if the given constructor is a branded ORM type
+     * (not a user subclass). Uses `Symbol.for()` so it works across CJS/ESM module graphs.
+     */
+    static getOrmType(cls: object): string | undefined;
 }

package/types/Type.js

@@ -1,4 +1,6 @@
 import { inspect } from '../logging/inspect.js';
+/** @internal */
+export const ORM_TYPE = Symbol.for('@mikro-orm/type');
 export class Type {
     static types = new Map();
     platform;
@@ -64,6 +66,14 @@ export class Type {
     static isMappedType(data) {
         return !!data?.__mappedType;
     }
+    /**
+     * @internal
+     * Returns the built-in type registry key if the given constructor is a branded ORM type
+     * (not a user subclass). Uses `Symbol.for()` so it works across CJS/ESM module graphs.
+     */
+    static getOrmType(cls) {
+        return Object.hasOwn(cls, ORM_TYPE) ? cls[ORM_TYPE] : undefined;
+    }
     /** @ignore */
     [Symbol.for('nodejs.util.inspect.custom')](depth = 2) {
         const object = { ...this };

package/types/index.js

@@ -19,7 +19,7 @@ import { StringType } from './StringType.js';
 import { TextType } from './TextType.js';
 import { TimeType } from './TimeType.js';
 import { TinyIntType } from './TinyIntType.js';
-import { Type } from './Type.js';
+import { ORM_TYPE, Type } from './Type.js';
 import { Uint8ArrayType } from './Uint8ArrayType.js';
 import { UnknownType } from './UnknownType.js';
 import { UuidType } from './UuidType.js';
@@ -51,3 +51,13 @@ export const types = {
     unknown: UnknownType,
 };
 export const t = types;
+/**
+ * Brand each built-in type constructor with its registry key via a cross-module symbol.
+ * Symbol.for() returns the same symbol across CJS/ESM module graphs, so this survives
+ * the dual-package hazard (e.g. when using tsx or @swc-node/register with "type": "commonjs").
+ * Using Object.defineProperty ensures the brand is an own (non-inherited) property,
+ * so subclasses (e.g. MyJsonType extends JsonType) won't be detected as built-in types.
+ */
+for (const [key, type] of Object.entries(types)) {
+    Object.defineProperty(type, ORM_TYPE, { value: key, enumerable: false });
+}

package/utils/Utils.js

@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.2-dev.1';
+    static #ORM_VERSION = '7.0.2-dev.11';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */