@mikro-orm/core 7.0.0-dev.169 → 7.0.0-dev.170

package/errors.d.ts

@@ -66,6 +66,7 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static targetKeyNotUnique(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
     static targetKeyNotFound(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
     static dangerousPropertyName(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
+    static viewEntityWithoutExpression(meta: EntityMetadata): MetadataError;
     private static fromMessage;
 }
 export declare class NotFoundError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {

package/errors.js

@@ -225,6 +225,9 @@ export class MetadataError extends ValidationError {
     static dangerousPropertyName(meta, prop) {
         return this.fromMessage(meta, prop, `uses a dangerous property name '${prop.name}' which could lead to prototype pollution. Please use a different property name.`);
     }
+    static viewEntityWithoutExpression(meta) {
+        return new MetadataError(`View entity ${meta.className} is missing 'expression'. View entities must have an expression defining the SQL query.`);
+    }
     static fromMessage(meta, prop, message) {
         return new MetadataError(`${meta.className}.${prop.name} ${message}`);
     }

package/metadata/MetadataValidator.d.ts

@@ -24,4 +24,9 @@ export declare class MetadataValidator {
      * @internal
      */
     private validatePropertyNames;
+    /**
+     * Validates view entity configuration.
+     * View entities must have an expression.
+     */
+    private validateViewEntity;
 }

package/metadata/MetadataValidator.js

@@ -19,7 +19,15 @@ const DANGEROUS_PROPERTY_NAMES = ['__proto__', 'constructor', 'prototype'];
 export class MetadataValidator {
     validateEntityDefinition(metadata, name, options) {
         const meta = metadata.get(name);
-        if (meta.virtual || meta.expression) {
+        // View entities (expression with view flag) behave like regular tables but are read-only
+        // They can have primary keys and are created as actual database views
+        if (meta.view) {
+            this.validateViewEntity(meta);
+            return;
+        }
+        // Virtual entities (expression without view flag) have restrictions - no PKs, limited relation types
+        // Note: meta.virtual is set later in sync(), so we check for expression && !view here
+        if (meta.virtual || (meta.expression && !meta.view)) {
             for (const prop of Utils.values(meta.properties)) {
                 if (![ReferenceKind.SCALAR, ReferenceKind.EMBEDDED, ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
                     throw new MetadataError(`Only scalars, embedded properties and to-many relations are allowed inside virtual entity. Found '${prop.kind}' in ${meta.className}.${prop.name}`);
@@ -240,4 +248,19 @@ export class MetadataValidator {
             }
         }
     }
+    /**
+     * Validates view entity configuration.
+     * View entities must have an expression.
+     */
+    validateViewEntity(meta) {
+        // View entities must have an expression
+        if (!meta.expression) {
+            throw MetadataError.viewEntityWithoutExpression(meta);
+        }
+        // Validate indexes if present
+        this.validateIndexes(meta, meta.indexes ?? [], 'index');
+        this.validateIndexes(meta, meta.uniques ?? [], 'unique');
+        // Validate property names
+        this.validatePropertyNames(meta);
+    }
 }

package/metadata/types.d.ts

@@ -27,11 +27,17 @@ export type EntityOptions<T, E = T extends EntityClass<infer P> ? P : T> = {
     abstract?: boolean;
     /** Disables change tracking - such entities are ignored during flush. */
     readonly?: boolean;
-    /** Marks entity as {@doclink virtual-entities | virtual}. This is set automatically when you use `expression` option. */
+    /** Marks entity as {@doclink virtual-entities | virtual}. This is set automatically when you use `expression` option (unless `view` is set). */
     virtual?: boolean;
+    /**
+     * Marks entity as a database view. Unlike virtual entities which evaluate expressions at query time,
+     * view entities create actual database views. The `expression` option must be provided when `view` is true.
+     * View entities are read-only by default.
+     */
+    view?: boolean;
     /** Used to make ORM aware of externally defined triggers. This is needed for MS SQL Server multi inserts, ignored in other dialects. */
     hasTriggers?: boolean;
-    /** SQL query that maps to a {@doclink virtual-entities | virtual entity}. */
+    /** SQL query that maps to a {@doclink virtual-entities | virtual entity}, or for view entities, the view definition. */
     expression?: string | ((em: any, where: ObjectQuery<E>, options: FindOptions<E, any, any, any>, stream?: boolean) => object);
     /** Set {@doclink repositories#custom-repository | custom repository class}. */
     repository?: () => Constructor;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mikro-orm/core",
   "type": "module",
-  "version": "7.0.0-dev.169",
+  "version": "7.0.0-dev.170",
   "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",

package/typings.d.ts

@@ -472,6 +472,8 @@ export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> =
     schema?: string;
     pivotTable?: boolean;
     virtual?: boolean;
+    /** True if this entity represents a database view (not a virtual entity). */
+    view?: boolean;
     expression?: string | ((em: any, where: ObjectQuery<Entity>, options: FindOptions<Entity, any, any, any>, stream?: boolean) => MaybePromise<Raw | object | string>);
     discriminatorColumn?: EntityKey<Entity> | AnyString;
     discriminatorValue?: number | string;

package/typings.js

@@ -109,7 +109,9 @@ export class EntityMetadata {
             return this.root.uniqueName === prop.targetMeta?.root.uniqueName;
         });
         this.hasUniqueProps = this.uniques.length + this.uniqueProps.length > 0;
-        this.virtual = !!this.expression;
+        // If `view` is set, this is a database view entity (not a virtual entity).
+        // Virtual entities evaluate expressions at query time, view entities create actual database views.
+        this.virtual = !!this.expression && !this.view;
         if (config) {
             for (const prop of this.props) {
                 if (prop.enum && !prop.nativeEnumName && prop.items?.every(item => typeof item === 'string')) {
@@ -132,7 +134,7 @@ export class EntityMetadata {
         for (const hook of Utils.keys(this.hooks)) {
             this.hooks[hook] = Utils.removeDuplicates(this.hooks[hook]);
         }
-        if (this.virtual) {
+        if (this.virtual || this.view) {
             this.readonly = true;
         }
         if (initIndexes && this.name) {

package/utils/Utils.js

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