@mikro-orm/core 7.0.17 → 7.0.18-dev.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.17",
+  "version": "7.0.18-dev.1",
   "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/platforms/Platform.d.ts

@@ -43,6 +43,8 @@ export declare abstract class Platform {
     getEnumArrayCheckConstraintExpression(column: string, items: string[]): string | null;
     /** Whether this platform supports materialized views. */
     supportsMaterializedViews(): boolean;
+    /** Whether this platform supports declarative table partitioning in schema generation. */
+    supportsPartitionedTables(): boolean;
     /** Returns the schema helper instance for this platform, or undefined if not supported. */
     getSchemaHelper(): unknown;
     /** Whether the platform automatically creates indexes on foreign key columns. */
@@ -211,6 +213,11 @@ export declare abstract class Platform {
     getFullTextWhereClause(prop: EntityProperty): string;
     supportsCreatingFullTextIndex(): boolean;
     getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
+    /**
+     * Generates the SQL index hint clause for the given index names.
+     * Returns `undefined` when the platform does not support index hints (e.g. PostgreSQL, SQLite).
+     */
+    formatIndexHint(indexNames: string[]): string | undefined;
     /** Whether the driver automatically parses JSON columns into JS objects. */
     convertsJsonAutomatically(): boolean;
     /** Converts a JS value to its JSON database representation (typically JSON.stringify). */

package/platforms/Platform.js

@@ -2,6 +2,7 @@ import { clone } from '../utils/clone.js';
 import { EntityRepository } from '../entity/EntityRepository.js';
 import { UnderscoreNamingStrategy } from '../naming-strategy/UnderscoreNamingStrategy.js';
 import { ExceptionConverter } from './ExceptionConverter.js';
+import { MetadataError } from '../errors.js';
 import { ArrayType, BigIntType, BlobType, BooleanType, CharacterType, DateTimeType, DateType, DecimalType, DoubleType, EnumType, FloatType, IntegerType, IntervalType, JsonType, MediumIntType, SmallIntType, StringType, TextType, TimeType, TinyIntType, Type, Uint8ArrayType, UnknownType, UuidType, } from '../types/index.js';
 import { parseJsonSafe, Utils } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
@@ -71,6 +72,10 @@ export class Platform {
     supportsMaterializedViews() {
         return false;
     }
+    /** Whether this platform supports declarative table partitioning in schema generation. */
+    supportsPartitionedTables() {
+        return false;
+    }
     /** Returns the schema helper instance for this platform, or undefined if not supported. */
     getSchemaHelper() {
         return undefined;
@@ -436,6 +441,13 @@ export class Platform {
     getFullTextIndexExpression(indexName, schemaName, tableName, columns) {
         throw new Error('Full text searching is not supported by this driver.');
     }
+    /**
+     * Generates the SQL index hint clause for the given index names.
+     * Returns `undefined` when the platform does not support index hints (e.g. PostgreSQL, SQLite).
+     */
+    formatIndexHint(indexNames) {
+        return undefined;
+    }
     /** Whether the driver automatically parses JSON columns into JS objects. */
     convertsJsonAutomatically() {
         return true;
@@ -689,7 +701,9 @@ export class Platform {
     }
     /** Platform-specific validation of entity metadata. */
     validateMetadata(meta) {
-        return;
+        if (meta.partitionBy && !this.supportsPartitionedTables()) {
+            throw new MetadataError(`Entity ${meta.className} uses partitionBy, but ${this.constructor.name} does not support partitioned tables`);
+        }
     }
     /**
      * Generates a custom order by statement given a set of in order values, eg.

package/serialization/EntitySerializer.d.ts

@@ -1,21 +1,33 @@
-import type { ArrayElement, AutoPath, CleanTypeConfig, ExtractFieldsHint, FromEntityType, SerializeDTO, TypeConfig, UnboxArray } from '../typings.js';
+import type { ArrayElement, AutoPath, CleanTypeConfig, ExtractFieldsHint, FromEntityType, ResolveSerializeFields, SerializeDTO, SerializeFieldsKeepPK, TypeConfig, UnboxArray } from '../typings.js';
 import { type PopulatePath } from '../enums.js';
-/** Converts entity instances to plain DTOs via `serialize()`, with fine-grained control over populate, exclude, and serialization groups. */
+/** Converts entity instances to plain DTOs via `serialize()`, with fine-grained control over populate, exclude, fields, and serialization groups. */
 export declare class EntitySerializer {
-    /** Serializes an entity to a plain DTO, with fine-grained control over population, exclusion, groups, and custom types. */
-    static serialize<T extends object, P extends string = never, E extends string = never>(entity: T, options?: SerializeOptions<T, P, E>): SerializeDTO<T, P, E>;
+    /** Serializes an entity to a plain DTO, with fine-grained control over population, exclusion, fields, groups, and custom types. */
+    static serialize<T extends object, P extends string = never, E extends string = never, F extends string = never>(entity: T, options?: SerializeOptions<T, P, E, F>): SerializeDTO<T, P, E, never, ResolveSerializeFields<F>, SerializeFieldsKeepPK<F>>;
     private static propertyName;
     private static processProperty;
     private static processCustomType;
     private static extractChildOptions;
+    /**
+     * Extracts the nested `fields` whitelist for a child property. A bare parent name (`fields: ['books']`) or a
+     * wildcard removes the whitelist on the sub-tree (everything is included), so consumers don't have to repeat
+     * every field of the child. Otherwise dot-paths are stripped of the parent prefix and passed down.
+     */
+    private static extractChildFields;
     private static processEntity;
     private static processCollection;
 }
-export interface SerializeOptions<T, P extends string = never, E extends string = never> {
+export interface SerializeOptions<T, P extends string = never, E extends string = never, F extends string = never> {
     /** Specify which relation should be serialized as populated and which as a FK. */
     populate?: readonly AutoPath<T, P, `${PopulatePath.ALL}`>[];
     /** Specify which properties should be omitted. */
     exclude?: readonly AutoPath<T, E>[];
+    /**
+     * Whitelist of properties to serialize, supports dot-paths (e.g. `['name', 'books.title']`). When set, only the
+     * listed properties end up in the output, including primary keys. A bare property name keeps its entire sub-tree;
+     * a dot-path additionally narrows the nested object to the listed sub-keys. `exclude` takes precedence on conflict.
+     */
+    fields?: readonly AutoPath<T, F, `${PopulatePath.ALL}`>[];
     /** Enforce unpopulated references to be returned as objects, e.g. `{ author: { id: 1 } }` instead of `{ author: 1 }`. */
     forceObject?: boolean;
     /** Ignore custom property serializers. */
@@ -41,4 +53,4 @@ export interface SerializeOptions<T, P extends string = never, E extends string
  * const dto2 = wrap(user).serialize({ exclude: ['id', 'email'], forceObject: true });
  * ```
  */
-export declare function serialize<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Populate extends string = never, Exclude extends string = never, Config extends TypeConfig = never>(entity: Entity, options?: Config & SerializeOptions<UnboxArray<Entity>, Populate, Exclude>): Naked extends object[] ? SerializeDTO<ArrayElement<Naked>, Populate, Exclude, CleanTypeConfig<Config>>[] : SerializeDTO<Naked, Populate, Exclude, CleanTypeConfig<Config>, ExtractFieldsHint<Entity>>;
+export declare function serialize<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Populate extends string = never, Exclude extends string = never, Fields extends string = never, Config extends TypeConfig = never>(entity: Entity, options?: Config & SerializeOptions<UnboxArray<Entity>, Populate, Exclude, Fields>): Naked extends object[] ? SerializeDTO<ArrayElement<Naked>, Populate, Exclude, CleanTypeConfig<Config>, ResolveSerializeFields<Fields, ExtractFieldsHint<Entity>>, SerializeFieldsKeepPK<Fields>>[] : SerializeDTO<Naked, Populate, Exclude, CleanTypeConfig<Config>, ResolveSerializeFields<Fields, ExtractFieldsHint<Entity>>, SerializeFieldsKeepPK<Fields>>;

package/serialization/EntitySerializer.js

@@ -4,13 +4,20 @@ import { ReferenceKind } from '../enums.js';
 import { Reference } from '../entity/Reference.js';
 import { SerializationContext } from './SerializationContext.js';
 import { isRaw } from '../utils/RawQueryFragment.js';
+/** Returns true when any entry in `items` is `propName`, the wildcard `*`, or a dot-path under `propName`. */
+function matchesPath(items, propName) {
+    return items.some(item => item === propName || item === '*' || item.startsWith(propName + '.'));
+}
 function isVisible(meta, propName, options) {
     const prop = meta.properties[propName];
     if (options.groups && prop?.groups) {
         return prop.groups.some(g => options.groups.includes(g));
     }
+    if (Array.isArray(options.fields) && options.fields.length > 0 && !matchesPath(options.fields, propName)) {
+        return false;
+    }
     if (Array.isArray(options.populate) &&
-        options.populate?.find(item => item === propName || item.startsWith(propName + '.'))) {
+        options.populate.find(item => item === propName || item.startsWith(propName + '.'))) {
         return true;
     }
     if (options.exclude?.find(item => item === propName)) {
@@ -22,7 +29,8 @@ function isVisible(meta, propName, options) {
 }
 function isPopulated(propName, options) {
     if (typeof options.populate !== 'boolean' &&
-        options.populate?.find(item => item === propName || item.startsWith(propName + '.') || item === '*')) {
+        Array.isArray(options.populate) &&
+        matchesPath(options.populate, propName)) {
         return true;
     }
     if (typeof options.populate === 'boolean') {
@@ -30,9 +38,9 @@ function isPopulated(propName, options) {
     }
     return false;
 }
-/** Converts entity instances to plain DTOs via `serialize()`, with fine-grained control over populate, exclude, and serialization groups. */
+/** Converts entity instances to plain DTOs via `serialize()`, with fine-grained control over populate, exclude, fields, and serialization groups. */
 export class EntitySerializer {
-    /** Serializes an entity to a plain DTO, with fine-grained control over population, exclusion, groups, and custom types. */
+    /** Serializes an entity to a plain DTO, with fine-grained control over population, exclusion, fields, groups, and custom types. */
     static serialize(entity, options = {}) {
         const wrapped = helper(entity);
         const meta = wrapped.__meta;
@@ -184,8 +192,27 @@ export class EntitySerializer {
                 ? Utils.extractChildElements(options.populate, prop, '*')
                 : options.populate,
             exclude: Array.isArray(options.exclude) ? Utils.extractChildElements(options.exclude, prop) : options.exclude,
+            fields: Array.isArray(options.fields) ? this.extractChildFields(options.fields, prop) : options.fields,
         };
     }
+    /**
+     * Extracts the nested `fields` whitelist for a child property. A bare parent name (`fields: ['books']`) or a
+     * wildcard removes the whitelist on the sub-tree (everything is included), so consumers don't have to repeat
+     * every field of the child. Otherwise dot-paths are stripped of the parent prefix and passed down.
+     */
+    static extractChildFields(fields, prop) {
+        const out = [];
+        const dotPrefix = prop + '.';
+        for (const field of fields) {
+            if (field === prop || field === '*') {
+                return undefined;
+            }
+            if (field.startsWith(dotPrefix)) {
+                out.push(field.substring(dotPrefix.length));
+            }
+        }
+        return out;
+    }
     static processEntity(prop, entity, platform, options) {
         const child = Reference.unwrapReference(entity[prop.name]);
         const wrapped = helper(child);