@mikro-orm/sql 7.0.15 → 7.0.16-dev.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.15",
+  "version": "7.0.16-dev.0",
   "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",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.0.15"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.15"
+    "@mikro-orm/core": "7.0.16-dev.0"
   },
   "engines": {
     "node": ">= 22.17.0"

package/plugin/index.d.ts

@@ -1,49 +1,42 @@
-import {
-  type KyselyPlugin,
-  type PluginTransformQueryArgs,
-  type PluginTransformResultArgs,
-  type QueryResult,
-  type RootOperationNode,
-  type UnknownRow,
-} from 'kysely';
+import { type KyselyPlugin, type PluginTransformQueryArgs, type PluginTransformResultArgs, type QueryResult, type RootOperationNode, type UnknownRow } from 'kysely';
 import type { SqlEntityManager } from '../SqlEntityManager.js';
 /** Configuration options for the MikroKyselyPlugin. */
 export interface MikroKyselyPluginOptions {
-  /**
-   * Use database table names ('table') or entity names ('entity') in queries.
-   *
-   * @default 'table'
-   */
-  tableNamingStrategy?: 'table' | 'entity';
-  /**
-   * Use database column names ('column') or property names ('property') in queries.
-   *
-   * @default 'column'
-   */
-  columnNamingStrategy?: 'column' | 'property';
-  /**
-   * Automatically process entity `onCreate` hooks in INSERT queries.
-   *
-   * @default false
-   */
-  processOnCreateHooks?: boolean;
-  /**
-   * Automatically process entity `onUpdate` hooks in UPDATE queries.
-   *
-   * @default false
-   */
-  processOnUpdateHooks?: boolean;
-  /**
-   * Convert JavaScript values to database-compatible values (e.g., Date to timestamp, custom types).
-   *
-   * @default false
-   */
-  convertValues?: boolean;
+    /**
+     * Use database table names ('table') or entity names ('entity') in queries.
+     *
+     * @default 'table'
+     */
+    tableNamingStrategy?: 'table' | 'entity';
+    /**
+     * Use database column names ('column') or property names ('property') in queries.
+     *
+     * @default 'column'
+     */
+    columnNamingStrategy?: 'column' | 'property';
+    /**
+     * Automatically process entity `onCreate` hooks in INSERT queries.
+     *
+     * @default false
+     */
+    processOnCreateHooks?: boolean;
+    /**
+     * Automatically process entity `onUpdate` hooks in UPDATE queries.
+     *
+     * @default false
+     */
+    processOnUpdateHooks?: boolean;
+    /**
+     * Convert JavaScript values to database-compatible values (e.g., Date to timestamp, custom types).
+     *
+     * @default false
+     */
+    convertValues?: boolean;
 }
 /** Kysely plugin that transforms queries and results to use MikroORM entity/property naming conventions. */
 export declare class MikroKyselyPlugin implements KyselyPlugin {
-  #private;
-  constructor(em: SqlEntityManager, options?: MikroKyselyPluginOptions);
-  transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
-  transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+    #private;
+    constructor(em: SqlEntityManager, options?: MikroKyselyPluginOptions);
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
 }

package/plugin/index.js

@@ -1,50 +1,43 @@
-import {
-  SelectQueryNode as SelectQueryNodeClass,
-  InsertQueryNode as InsertQueryNodeClass,
-  UpdateQueryNode as UpdateQueryNodeClass,
-  DeleteQueryNode as DeleteQueryNodeClass,
-} from 'kysely';
+import { SelectQueryNode as SelectQueryNodeClass, InsertQueryNode as InsertQueryNodeClass, UpdateQueryNode as UpdateQueryNodeClass, DeleteQueryNode as DeleteQueryNodeClass, } from 'kysely';
 import { MikroTransformer } from './transformer.js';
 /** Kysely plugin that transforms queries and results to use MikroORM entity/property naming conventions. */
 export class MikroKyselyPlugin {
-  static #queryNodeCache = new WeakMap();
-  #transformer;
-  #options;
-  constructor(em, options = {}) {
-    this.#options = options;
-    this.#transformer = new MikroTransformer(em, options);
-  }
-  transformQuery(args) {
-    this.#transformer.reset();
-    const result = this.#transformer.transformNode(args.node, args.queryId);
-    // Cache the entity map if it is one we can process (for use in transformResult)
-    if (
-      SelectQueryNodeClass.is(args.node) ||
-      InsertQueryNodeClass.is(args.node) ||
-      UpdateQueryNodeClass.is(args.node) ||
-      DeleteQueryNodeClass.is(args.node)
-    ) {
-      // clone the entityMap because the transformer's internal map will be cleared and reused by the next query
-      const entityMap = new Map(this.#transformer.getOutputEntityMap());
-      MikroKyselyPlugin.#queryNodeCache.set(args.queryId, { entityMap });
+    static #queryNodeCache = new WeakMap();
+    #transformer;
+    #options;
+    constructor(em, options = {}) {
+        this.#options = options;
+        this.#transformer = new MikroTransformer(em, options);
     }
-    return result;
-  }
-  async transformResult(args) {
-    // Only transform results if columnNamingStrategy is 'property' or convertValues is true
-    if (this.#options.columnNamingStrategy !== 'property' && !this.#options.convertValues) {
-      return args.result;
+    transformQuery(args) {
+        this.#transformer.reset();
+        const result = this.#transformer.transformNode(args.node, args.queryId);
+        // Cache the entity map if it is one we can process (for use in transformResult)
+        if (SelectQueryNodeClass.is(args.node) ||
+            InsertQueryNodeClass.is(args.node) ||
+            UpdateQueryNodeClass.is(args.node) ||
+            DeleteQueryNodeClass.is(args.node)) {
+            // clone the entityMap because the transformer's internal map will be cleared and reused by the next query
+            const entityMap = new Map(this.#transformer.getOutputEntityMap());
+            MikroKyselyPlugin.#queryNodeCache.set(args.queryId, { entityMap });
+        }
+        return result;
     }
-    // Retrieve the cached query node and metadata
-    const cache = MikroKyselyPlugin.#queryNodeCache.get(args.queryId);
-    if (!cache) {
-      return args.result;
+    async transformResult(args) {
+        // Only transform results if columnNamingStrategy is 'property' or convertValues is true
+        if (this.#options.columnNamingStrategy !== 'property' && !this.#options.convertValues) {
+            return args.result;
+        }
+        // Retrieve the cached query node and metadata
+        const cache = MikroKyselyPlugin.#queryNodeCache.get(args.queryId);
+        if (!cache) {
+            return args.result;
+        }
+        // Transform the result rows using the transformer
+        const transformedRows = this.#transformer.transformResult(args.result.rows ?? [], cache.entityMap);
+        return {
+            ...args.result,
+            rows: transformedRows ?? [],
+        };
     }
-    // Transform the result rows using the transformer
-    const transformedRows = this.#transformer.transformResult(args.result.rows ?? [], cache.entityMap);
-    return {
-      ...args.result,
-      rows: transformedRows ?? [],
-    };
-  }
 }

package/plugin/transformer.d.ts

@@ -1,141 +1,107 @@
 import { type EntityMetadata, type EntityProperty, type Type } from '@mikro-orm/core';
-import {
-  type CommonTableExpressionNameNode,
-  type DeleteQueryNode,
-  type InsertQueryNode,
-  type JoinNode,
-  type MergeQueryNode,
-  type OperationNode,
-  type QueryId,
-  type SelectQueryNode,
-  type UpdateQueryNode,
-  type WithNode,
-  ColumnNode,
-  IdentifierNode,
-  OperationNodeTransformer,
-  SelectionNode,
-  TableNode,
-  ValueNode,
-} from 'kysely';
+import { type CommonTableExpressionNameNode, type DeleteQueryNode, type InsertQueryNode, type JoinNode, type MergeQueryNode, type OperationNode, type QueryId, type SelectQueryNode, type UpdateQueryNode, type WithNode, ColumnNode, IdentifierNode, OperationNodeTransformer, SelectionNode, TableNode, ValueNode } from 'kysely';
 import type { MikroKyselyPluginOptions } from './index.js';
 import type { SqlEntityManager } from '../SqlEntityManager.js';
 export declare class MikroTransformer extends OperationNodeTransformer {
-  #private;
-  constructor(em: SqlEntityManager, options?: MikroKyselyPluginOptions);
-  reset(): void;
-  getOutputEntityMap(): Map<string, EntityMetadata>;
-  /** @internal */
-  getContextStack(): Map<string, EntityMetadata | undefined>[];
-  /** @internal */
-  getSubqueryAliasMap(): Map<string, EntityMetadata | undefined>;
-  transformSelectQuery(node: SelectQueryNode, queryId: QueryId): SelectQueryNode;
-  transformInsertQuery(node: InsertQueryNode, queryId?: QueryId): InsertQueryNode;
-  transformUpdateQuery(node: UpdateQueryNode, queryId?: QueryId): UpdateQueryNode;
-  transformDeleteQuery(node: DeleteQueryNode, queryId?: QueryId): DeleteQueryNode;
-  transformMergeQuery(node: MergeQueryNode, queryId?: QueryId): MergeQueryNode;
-  transformIdentifier(node: IdentifierNode, queryId: QueryId): IdentifierNode;
-  /**
-   * Find owner entity metadata for the current identifier in the context stack.
-   * Supports both aliased and non-aliased table references.
-   * Searches up the context stack to support correlated subqueries.
-   * Also checks subquery/CTE aliases to resolve to their source tables.
-   */
-  findOwnerEntityInContext(): EntityMetadata | undefined;
-  processOnCreateHooks(node: InsertQueryNode, meta: EntityMetadata): InsertQueryNode;
-  processOnUpdateHooks(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
-  processInsertValues(node: InsertQueryNode, meta: EntityMetadata): InsertQueryNode;
-  processUpdateValues(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
-  processInputValueNode(
-    prop: EntityProperty | undefined,
-    fieldName: string | undefined,
-    valueNode: ValueNode,
-  ): OperationNode;
-  expandSelections(selections: readonly SelectionNode[]): readonly SelectionNode[];
-  expandSelection(sel: SelectionNode): SelectionNode[] | null;
-  expandStar(
-    meta: EntityMetadata | undefined,
-    table: TableNode | undefined,
-    tableName: string | undefined,
-  ): SelectionNode[] | null;
-  wrapRead(customType: Type<any>, fieldName: string, tableName: string | undefined): SelectionNode;
-  wrapWrite(prop: EntityProperty | undefined, fieldName: string | undefined, valueNode: ValueNode): OperationNode;
-  /** Resolve the customType for a specific field name (handles composite-PK FK fan-out via prop.customTypes[]). */
-  fieldType(prop: EntityProperty, fieldName: string): Type<any> | undefined;
-  findOwnerMeta(name: string | undefined): EntityMetadata | undefined;
-  mapColumnsToProperties(columns: readonly ColumnNode[], meta: EntityMetadata): (EntityProperty | undefined)[];
-  normalizeColumnName(identifier: IdentifierNode): string;
-  findProperty(meta: EntityMetadata | undefined, columnName?: string): EntityProperty | undefined;
-  prepareInputValue(prop: EntityProperty | undefined, value: unknown, enabled: boolean): unknown;
-  /**
-   * Look up a table name/alias in the context stack.
-   * Searches from current scope (top of stack) to parent scopes (bottom).
-   * This supports correlated subqueries and references to outer query tables.
-   */
-  lookupInContextStack(tableNameOrAlias: string): EntityMetadata | undefined;
-  /**
-   * Process WITH node (CTE definitions)
-   */
-  processWithNode(withNode: WithNode, context: Map<string, EntityMetadata | undefined>): void;
-  /**
-   * Extract CTE name from CommonTableExpressionNameNode
-   */
-  getCTEName(nameNode: CommonTableExpressionNameNode): string | undefined;
-  /**
-   * Process a FROM item (can be TableNode or AliasNode)
-   */
-  processFromItem(
-    from: any, // OperationNode type - can be TableNode, AliasNode, or SelectQueryNode
-    context: Map<string, EntityMetadata | undefined>,
-  ): void;
-  /**
-   * Process a JOIN node
-   */
-  processJoinNode(join: JoinNode, context: Map<string, EntityMetadata | undefined>): void;
-  /**
-   * Extract the primary source table from a SELECT query
-   * This helps resolve columns from subqueries to their original entity tables
-   */
-  extractSourceTableFromSelectQuery(selectQuery: SelectQueryNode): EntityMetadata | undefined;
-  /**
-   * Extract alias name from an alias node
-   */
-  extractAliasName(alias: any): string | undefined;
-  /**
-   * Extract table name from a TableNode
-   */
-  getTableName(node: TableNode | undefined): string | undefined;
-  /**
-   * Find entity metadata by table name or entity name
-   */
-  findEntityMetadata(name: string): EntityMetadata | undefined;
-  /**
-   * Transform result rows by mapping database column names to property names
-   * This is called for SELECT queries when columnNamingStrategy is 'property'
-   */
-  transformResult(
-    rows: Record<string, any>[] | undefined,
-    entityMap: Map<string, EntityMetadata>,
-  ): Record<string, any>[] | undefined;
-  buildGlobalFieldMap(entityMap: Map<string, EntityMetadata>): Record<string, EntityProperty>;
-  buildGlobalRelationFieldMap(entityMap: Map<string, EntityMetadata>): Record<string, string>;
-  /**
-   * Build a mapping from database field names to property objects
-   * Format: { 'field_name': EntityProperty }
-   */
-  buildFieldToPropertyMap(meta: EntityMetadata, alias?: string): Record<string, EntityProperty>;
-  /**
-   * Build a mapping for relation fields
-   * For ManyToOne relations, we need to map from the foreign key field to the relation property
-   * Format: { 'foreign_key_field': 'relationPropertyName' }
-   */
-  buildRelationFieldMap(meta: EntityMetadata, alias?: string): Record<string, string>;
-  /**
-   * Transform a single row by mapping column names to property names
-   */
-  transformRow(
-    row: Record<string, any>,
-    fieldToPropertyMap: Record<string, EntityProperty>,
-    relationFieldMap: Record<string, string>,
-  ): Record<string, any>;
-  prepareOutputValue(prop: EntityProperty | undefined, value: unknown): unknown;
+    #private;
+    constructor(em: SqlEntityManager, options?: MikroKyselyPluginOptions);
+    reset(): void;
+    getOutputEntityMap(): Map<string, EntityMetadata>;
+    /** @internal */
+    getContextStack(): Map<string, EntityMetadata | undefined>[];
+    /** @internal */
+    getSubqueryAliasMap(): Map<string, EntityMetadata | undefined>;
+    transformSelectQuery(node: SelectQueryNode, queryId: QueryId): SelectQueryNode;
+    transformInsertQuery(node: InsertQueryNode, queryId?: QueryId): InsertQueryNode;
+    transformUpdateQuery(node: UpdateQueryNode, queryId?: QueryId): UpdateQueryNode;
+    transformDeleteQuery(node: DeleteQueryNode, queryId?: QueryId): DeleteQueryNode;
+    transformMergeQuery(node: MergeQueryNode, queryId?: QueryId): MergeQueryNode;
+    transformIdentifier(node: IdentifierNode, queryId: QueryId): IdentifierNode;
+    /**
+     * Find owner entity metadata for the current identifier in the context stack.
+     * Supports both aliased and non-aliased table references.
+     * Searches up the context stack to support correlated subqueries.
+     * Also checks subquery/CTE aliases to resolve to their source tables.
+     */
+    findOwnerEntityInContext(): EntityMetadata | undefined;
+    processOnCreateHooks(node: InsertQueryNode, meta: EntityMetadata): InsertQueryNode;
+    processOnUpdateHooks(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
+    processInsertValues(node: InsertQueryNode, meta: EntityMetadata): InsertQueryNode;
+    processUpdateValues(node: UpdateQueryNode, meta: EntityMetadata): UpdateQueryNode;
+    processInputValueNode(prop: EntityProperty | undefined, fieldName: string | undefined, valueNode: ValueNode): OperationNode;
+    expandSelections(selections: readonly SelectionNode[]): readonly SelectionNode[];
+    expandSelection(sel: SelectionNode): SelectionNode[] | null;
+    expandStar(meta: EntityMetadata | undefined, table: TableNode | undefined, tableName: string | undefined): SelectionNode[] | null;
+    wrapRead(customType: Type<any>, fieldName: string, tableName: string | undefined): SelectionNode;
+    wrapWrite(prop: EntityProperty | undefined, fieldName: string | undefined, valueNode: ValueNode): OperationNode;
+    /** Resolve the customType for a specific field name (handles composite-PK FK fan-out via prop.customTypes[]). */
+    fieldType(prop: EntityProperty, fieldName: string): Type<any> | undefined;
+    findOwnerMeta(name: string | undefined): EntityMetadata | undefined;
+    mapColumnsToProperties(columns: readonly ColumnNode[], meta: EntityMetadata): (EntityProperty | undefined)[];
+    normalizeColumnName(identifier: IdentifierNode): string;
+    findProperty(meta: EntityMetadata | undefined, columnName?: string): EntityProperty | undefined;
+    prepareInputValue(prop: EntityProperty | undefined, value: unknown, enabled: boolean): unknown;
+    /**
+     * Look up a table name/alias in the context stack.
+     * Searches from current scope (top of stack) to parent scopes (bottom).
+     * This supports correlated subqueries and references to outer query tables.
+     */
+    lookupInContextStack(tableNameOrAlias: string): EntityMetadata | undefined;
+    /**
+     * Process WITH node (CTE definitions)
+     */
+    processWithNode(withNode: WithNode, context: Map<string, EntityMetadata | undefined>): void;
+    /**
+     * Extract CTE name from CommonTableExpressionNameNode
+     */
+    getCTEName(nameNode: CommonTableExpressionNameNode): string | undefined;
+    /**
+     * Process a FROM item (can be TableNode or AliasNode)
+     */
+    processFromItem(from: any, // OperationNode type - can be TableNode, AliasNode, or SelectQueryNode
+    context: Map<string, EntityMetadata | undefined>): void;
+    /**
+     * Process a JOIN node
+     */
+    processJoinNode(join: JoinNode, context: Map<string, EntityMetadata | undefined>): void;
+    /**
+     * Extract the primary source table from a SELECT query
+     * This helps resolve columns from subqueries to their original entity tables
+     */
+    extractSourceTableFromSelectQuery(selectQuery: SelectQueryNode): EntityMetadata | undefined;
+    /**
+     * Extract alias name from an alias node
+     */
+    extractAliasName(alias: any): string | undefined;
+    /**
+     * Extract table name from a TableNode
+     */
+    getTableName(node: TableNode | undefined): string | undefined;
+    /**
+     * Find entity metadata by table name or entity name
+     */
+    findEntityMetadata(name: string): EntityMetadata | undefined;
+    /**
+     * Transform result rows by mapping database column names to property names
+     * This is called for SELECT queries when columnNamingStrategy is 'property'
+     */
+    transformResult(rows: Record<string, any>[] | undefined, entityMap: Map<string, EntityMetadata>): Record<string, any>[] | undefined;
+    buildGlobalFieldMap(entityMap: Map<string, EntityMetadata>): Record<string, EntityProperty>;
+    buildGlobalRelationFieldMap(entityMap: Map<string, EntityMetadata>): Record<string, string>;
+    /**
+     * Build a mapping from database field names to property objects
+     * Format: { 'field_name': EntityProperty }
+     */
+    buildFieldToPropertyMap(meta: EntityMetadata, alias?: string): Record<string, EntityProperty>;
+    /**
+     * Build a mapping for relation fields
+     * For ManyToOne relations, we need to map from the foreign key field to the relation property
+     * Format: { 'foreign_key_field': 'relationPropertyName' }
+     */
+    buildRelationFieldMap(meta: EntityMetadata, alias?: string): Record<string, string>;
+    /**
+     * Transform a single row by mapping column names to property names
+     */
+    transformRow(row: Record<string, any>, fieldToPropertyMap: Record<string, EntityProperty>, relationFieldMap: Record<string, string>): Record<string, any>;
+    prepareOutputValue(prop: EntityProperty | undefined, value: unknown): unknown;
 }