@mikro-orm/sql 7.0.0-rc.2 → 7.0.0

package/package.json

@@ -1,44 +1,44 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-rc.2",
+  "version": "7.0.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.",
-  "type": "module",
-  "exports": {
-    "./package.json": "./package.json",
-    ".": "./index.js"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
-  },
   "keywords": [
-    "orm",
+    "data-mapper",
+    "ddd",
+    "entity",
+    "identity-map",
+    "javascript",
+    "js",
+    "mariadb",
+    "mikro-orm",
     "mongo",
     "mongodb",
     "mysql",
-    "mariadb",
+    "orm",
     "postgresql",
     "sqlite",
     "sqlite3",
     "ts",
     "typescript",
-    "js",
-    "javascript",
-    "entity",
-    "ddd",
-    "mikro-orm",
-    "unit-of-work",
-    "data-mapper",
-    "identity-map"
+    "unit-of-work"
   ],
-  "author": "Martin Adámek",
-  "license": "MIT",
+  "homepage": "https://mikro-orm.io",
   "bugs": {
     "url": "https://github.com/mikro-orm/mikro-orm/issues"
   },
-  "homepage": "https://mikro-orm.io",
-  "engines": {
-    "node": ">= 22.17.0"
+  "license": "MIT",
+  "author": "Martin Adámek",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./index.js"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "scripts": {
     "build": "yarn compile && yarn copy",
@@ -46,16 +46,16 @@
     "compile": "yarn run -T tsc -p tsconfig.build.json",
     "copy": "node ../../scripts/copy.mjs"
   },
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
     "kysely": "0.28.11"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.6.4"
+    "@mikro-orm/core": "^7.0.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-rc.2"
+    "@mikro-orm/core": "^6.0.0"
+  },
+  "engines": {
+    "node": ">= 22.17.0"
   }
 }

package/plugin/index.d.ts

@@ -1,14 +1,5 @@
 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.
@@ -42,12 +33,8 @@ export interface MikroKyselyPluginOptions {
     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;
+    #private;
     constructor(em: SqlEntityManager, options?: MikroKyselyPluginOptions);
     transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
     transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
 }
-export {};

package/plugin/index.js

@@ -1,39 +1,39 @@
 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;
+    static #queryNodeCache = new WeakMap();
+    #transformer;
+    #options;
     constructor(em, options = {}) {
-        this.em = em;
-        this.options = options;
-        this.transformer = new MikroTransformer(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);
+        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() });
+            // 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;
     }
     async transformResult(args) {
         // Only transform results if columnNamingStrategy is 'property' or convertValues is true
-        if (this.options.columnNamingStrategy !== 'property' && !this.options.convertValues) {
+        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);
+        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);
+        const transformedRows = this.#transformer.transformResult(args.result.rows ?? [], cache.entityMap);
         return {
             ...args.result,
             rows: transformedRows ?? [],

package/plugin/transformer.d.ts

@@ -1,32 +1,16 @@
-import { type EntityMetadata, type EntityProperty, type MetadataStorage } from '@mikro-orm/core';
+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 { 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, import("@mikro-orm/core").EntityCtor<any>>>;
+    #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;