@mikro-orm/knex 7.0.0-dev.9 → 7.0.0-dev.91

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "7.0.0-dev.9",
+  "version": "7.0.0-dev.91",
   "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.",
   "type": "module",
   "exports": {
@@ -38,7 +38,7 @@
   },
   "homepage": "https://mikro-orm.io",
   "engines": {
-    "node": ">= 22.11.0"
+    "node": ">= 22.17.0"
   },
   "scripts": {
     "build": "yarn clean && yarn compile && yarn copy",
@@ -50,13 +50,13 @@
     "access": "public"
   },
   "dependencies": {
-    "kysely": "0.28.0",
+    "kysely": "0.28.8",
     "sqlstring": "2.3.3"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.4.13"
+    "@mikro-orm/core": "^6.6.2"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.9"
+    "@mikro-orm/core": "7.0.0-dev.91"
   }
 }

package/plugin/index.d.ts

@@ -0,0 +1,53 @@
+import { type KyselyPlugin, type PluginTransformQueryArgs, type PluginTransformResultArgs, type QueryResult, type RootOperationNode, type UnknownRow } from 'kysely';
+import { MikroTransformer } from './transformer.js';
+import type { SqlEntityManager } from '../SqlEntityManager.js';
+import type { EntityMetadata } from '@mikro-orm/core';
+/**
+ * Cache for query transformation data
+ * Stores the query node and metadata about tables/aliases
+ */
+interface QueryTransformCache {
+    entityMap: Map<string, EntityMetadata>;
+}
+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;
+}
+export declare class MikroKyselyPlugin implements KyselyPlugin {
+    protected readonly em: SqlEntityManager;
+    protected readonly options: MikroKyselyPluginOptions;
+    protected static queryNodeCache: WeakMap<any, QueryTransformCache>;
+    protected readonly transformer: MikroTransformer;
+    constructor(em: SqlEntityManager, options?: MikroKyselyPluginOptions);
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+}
+export {};

package/plugin/index.js

@@ -0,0 +1,42 @@
+import { SelectQueryNode as SelectQueryNodeClass, InsertQueryNode as InsertQueryNodeClass, UpdateQueryNode as UpdateQueryNodeClass, DeleteQueryNode as DeleteQueryNodeClass, } from 'kysely';
+import { MikroTransformer } from './transformer.js';
+export class MikroKyselyPlugin {
+    em;
+    options;
+    static queryNodeCache = new WeakMap();
+    transformer;
+    constructor(em, options = {}) {
+        this.em = em;
+        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)) {
+            MikroKyselyPlugin.queryNodeCache.set(args.queryId, { entityMap: this.transformer.getOutputEntityMap() });
+        }
+        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;
+        }
+        // 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

@@ -0,0 +1,115 @@
+import { type EntityMetadata, type EntityProperty, type MetadataStorage } 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 { MikroKyselyPluginOptions } from './index.js';
+import type { SqlEntityManager } from '../SqlEntityManager.js';
+import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
+export declare class MikroTransformer extends OperationNodeTransformer {
+    protected readonly em: SqlEntityManager;
+    protected readonly options: MikroKyselyPluginOptions;
+    /**
+     * Context stack to support nested queries (subqueries, CTEs)
+     * Each level of query scope has its own Map of table aliases/names to EntityMetadata
+     * Top of stack (highest index) is the current scope
+     */
+    protected readonly contextStack: Map<string, EntityMetadata | undefined>[];
+    /**
+     * Subquery alias map: maps subquery/CTE alias to its source table metadata
+     * Used to resolve columns from subqueries/CTEs to their original table definitions
+     */
+    protected readonly subqueryAliasMap: Map<string, EntityMetadata | undefined>;
+    protected readonly metadata: MetadataStorage;
+    protected readonly platform: AbstractSqlPlatform;
+    /**
+     * Global map of all entities involved in the query.
+     * Populated during AST transformation and used for result transformation.
+     */
+    protected readonly entityMap: Map<string, EntityMetadata<any>>;
+    constructor(em: SqlEntityManager, options?: MikroKyselyPluginOptions);
+    reset(): void;
+    getOutputEntityMap(): Map<string, EntityMetadata>;
+    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;
+}