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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "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",
@@ -47,13 +47,13 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "kysely": "0.28.11"
+    "kysely": "0.28.12"
   },
   "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"
   },
   "engines": {
     "node": ">= 22.17.0"

package/plugin/index.d.ts

@@ -1,40 +1,49 @@
-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,42 +1,50 @@
-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);
+  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 });
     }
-    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;
+    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;
     }
-    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 ?? [],
-        };
+    // 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 ?? [],
+    };
+  }
 }

package/plugin/transformer.d.ts

@@ -1,99 +1,122 @@
 import { type EntityMetadata, type EntityProperty } from '@mikro-orm/core';
-import { type CommonTableExpressionNameNode, type DeleteQueryNode, type IdentifierNode, type InsertQueryNode, type JoinNode, type MergeQueryNode, type QueryId, type SelectQueryNode, type UpdateQueryNode, type WithNode, ColumnNode, OperationNodeTransformer, TableNode } from 'kysely';
+import {
+  type CommonTableExpressionNameNode,
+  type DeleteQueryNode,
+  type IdentifierNode,
+  type InsertQueryNode,
+  type JoinNode,
+  type MergeQueryNode,
+  type QueryId,
+  type SelectQueryNode,
+  type UpdateQueryNode,
+  type WithNode,
+  ColumnNode,
+  OperationNodeTransformer,
+  TableNode,
+} 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;
-    mapColumnsToProperties(columns: readonly ColumnNode[], meta: EntityMetadata): (EntityProperty | undefined)[];
-    normalizeColumnName(identifier: IdentifierNode): string;
-    findProperty(meta: EntityMetadata | undefined, columnName?: string): EntityProperty | undefined;
-    shouldConvertValues(): boolean;
-    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;
+  mapColumnsToProperties(columns: readonly ColumnNode[], meta: EntityMetadata): (EntityProperty | undefined)[];
+  normalizeColumnName(identifier: IdentifierNode): string;
+  findProperty(meta: EntityMetadata | undefined, columnName?: string): EntityProperty | undefined;
+  shouldConvertValues(): boolean;
+  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;
 }