@mikro-orm/sql 7.0.0-rc.3 → 7.0.1-dev.0

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -19,7 +19,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         return `set names '${charset}';\n\n`;
     }
     getCreateDatabaseSQL(name) {
-        return `create database ${name}`;
+        return `create database ${this.quote(name)}`;
     }
     getListTablesSQL() {
         return (`select table_name, table_schema as schema_name, ` +
@@ -152,7 +152,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             if (index.condeferrable) {
                 indexDef.deferMode = index.condeferred ? DeferMode.INITIALLY_DEFERRED : DeferMode.INITIALLY_IMMEDIATE;
             }
-            if (index.index_def.some((col) => col.match(/[(): ,"'`]/)) || index.expression?.match(/ where /i)) {
+            if (index.index_def.some((col) => /[(): ,"'`]/.exec(col)) || index.expression?.match(/ where /i)) {
                 indexDef.expression = index.expression;
             }
             if (index.deferrable) {
@@ -190,7 +190,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         // Extract just the column list from the expression (between first parens after USING)
         // Pattern: ... USING method (...columns...) [INCLUDE (...)] [WHERE ...]
         // Note: pg_get_indexdef always returns a valid expression with USING clause
-        const usingMatch = expression.match(/using\s+\w+\s*\(/i);
+        const usingMatch = /using\s+\w+\s*\(/i.exec(expression);
         const startIdx = usingMatch.index + usingMatch[0].length - 1; // Position of opening (
         const columnsStr = this.extractParenthesizedContent(expression, startIdx);
         // Use the column names from columnDefs and find their modifiers in the expression
@@ -209,12 +209,12 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                     result.sort = 'DESC';
                 }
                 // Extract NULLS ordering
-                const nullsMatch = modifiers.match(/nulls\s+(first|last)/i);
+                const nullsMatch = /nulls\s+(first|last)/i.exec(modifiers);
                 if (nullsMatch) {
                     result.nulls = nullsMatch[1].toUpperCase();
                 }
                 // Extract collation
-                const collateMatch = modifiers.match(/collate\s+"?([^"\s,)]+)"?/i);
+                const collateMatch = /collate\s+"?([^"\s,)]+)"?/i.exec(modifiers);
                 if (collateMatch) {
                     result.collation = collateMatch[1];
                 }
@@ -333,7 +333,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
             }
             seen.add(dedupeKey);
             ret[key] ??= [];
-            const m = check.expression.match(/^check \(\((.*)\)\)$/is);
+            const m = /^check \(\((.*)\)\)$/is.exec(check.expression);
             const def = m?.[1].replace(/\((.*?)\)::\w+/g, '$1');
             ret[key].push({
                 name: check.name,
@@ -362,7 +362,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const allFks = await connection.execute(sql);
         const ret = {};
         function mapReferentialIntegrity(value, def) {
-            const match = ['n', 'd'].includes(value) && def.match(/ON DELETE (SET (NULL|DEFAULT) \(.*?\))/);
+            const match = ['n', 'd'].includes(value) && /ON DELETE (SET (NULL|DEFAULT) \(.*?\))/.exec(def);
             if (match) {
                 return match[1];
             }
@@ -465,10 +465,10 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 let items;
                 /* v8 ignore next */
                 if (m3) {
-                    items = m3.map((item) => item.trim().match(/^\(?'(.*)'/)?.[1]);
+                    items = m3.map((item) => /^\(?'(.*)'/.exec(item.trim())?.[1]);
                 }
                 else {
-                    items = m2[1].split(',').map((item) => item.trim().match(/^\(?'(.*)'/)?.[1]);
+                    items = m2[1].split(',').map((item) => /^\(?'(.*)'/.exec(item.trim())?.[1]);
                 }
                 items = items.filter(item => item !== undefined);
                 if (items.length > 0) {
@@ -605,7 +605,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         if (!defaultValue || typeof defaultValue !== 'string') {
             return super.normalizeDefaultValue(defaultValue, length, PostgreSqlSchemaHelper.DEFAULT_VALUES);
         }
-        const match = defaultValue.match(/^'(.*)'::(.*)$/);
+        const match = /^'(.*)'::(.*)$/.exec(defaultValue);
         if (match) {
             if (match[2] === 'integer') {
                 return +match[1];
@@ -617,8 +617,8 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
     appendComments(table) {
         const sql = [];
         if (table.comment) {
-            const comment = this.platform.quoteValue(table.comment).replace(/^'|'$/g, '');
-            sql.push(`comment on table ${table.getQuotedName()} is ${this.platform.quoteValue(this.processComment(comment))}`);
+            const comment = this.platform.quoteValue(this.processComment(table.comment));
+            sql.push(`comment on table ${table.getQuotedName()} is ${comment}`);
         }
         for (const column of table.getColumns()) {
             if (column.comment) {
@@ -723,7 +723,7 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
       order by pgc.conname`;
     }
     inferLengthFromColumnType(type) {
-        const match = type.match(/^(\w+(?:\s+\w+)*)\s*(?:\(\s*(\d+)\s*\)|$)/);
+        const match = /^(\w+(?:\s+\w+)*)\s*(?:\(\s*(\d+)\s*\)|$)/.exec(type);
         if (!match) {
             return;
         }

package/dialects/sqlite/SqlitePlatform.d.ts

@@ -75,5 +75,6 @@ export declare class SqlitePlatform extends AbstractSqlPlatform {
     convertVersionValue(value: Date | number, prop: EntityProperty): number | {
         $in: (string | number)[];
     };
+    getJsonArrayElementPropertySQL(alias: string, property: string, _type: string): string;
     quoteValue(value: any): string;
 }

package/dialects/sqlite/SqlitePlatform.js

@@ -133,6 +133,9 @@ export class SqlitePlatform extends AbstractSqlPlatform {
         }
         return value;
     }
+    getJsonArrayElementPropertySQL(alias, property, _type) {
+        return `json_extract(${this.quoteIdentifier(alias)}.value, '$.${this.quoteJsonKey(property)}')`;
+    }
     quoteValue(value) {
         if (value instanceof Date) {
             return '' + +value;

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -220,7 +220,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
         const columns = {};
         const constraints = [];
         // extract all columns definitions
-        let columnsDef = sql.replaceAll('\n', '').match(new RegExp(`create table [\`"']?.*?[\`"']? \\((.*)\\)`, 'i'))?.[1];
+        let columnsDef = new RegExp(`create table [\`"']?.*?[\`"']? \\((.*)\\)`, 'i').exec(sql.replaceAll('\n', ''))?.[1];
         /* v8 ignore next */
         if (columnsDef) {
             if (columnsDef.includes(', constraint ')) {
@@ -230,7 +230,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
             for (let i = cols.length - 1; i >= 0; i--) {
                 const col = cols[i];
                 const re = ` *, *[\`"']?${col.name}[\`"']? (.*)`;
-                const columnDef = columnsDef.match(new RegExp(re, 'i'));
+                const columnDef = new RegExp(re, 'i').exec(columnsDef);
                 if (columnDef) {
                     columns[col.name] = { name: col.name, definition: columnDef[1] };
                     columnsDef = columnsDef.substring(0, columnDef.index);
@@ -260,7 +260,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
      * Extracts the SELECT part from a CREATE VIEW statement.
      */
     extractViewDefinition(viewDefinition) {
-        const match = viewDefinition?.match(/create\s+view\s+[`"']?\w+[`"']?\s+as\s+(.*)/i);
+        const match = /create\s+view\s+[`"']?\w+[`"']?\s+as\s+(.*)/i.exec(viewDefinition);
         /* v8 ignore next - fallback for non-standard view definitions */
         return match ? match[1] : viewDefinition;
     }
@@ -307,7 +307,11 @@ export class SqliteSchemaHelper extends SchemaHelper {
             return null;
         }
         // simple values that are returned as-is from pragma (no wrapping needed)
-        if (/^-?\d/.test(value) || /^[xX]'/.test(value) || value[0] === "'" || value[0] === '"' || value[0] === '(') {
+        if (/^-?\d/.test(value) ||
+            /^[xX]'/.test(value) ||
+            value.startsWith("'") ||
+            value.startsWith('"') ||
+            value.startsWith('(')) {
             return value;
         }
         const lower = value.toLowerCase();
@@ -325,10 +329,10 @@ export class SqliteSchemaHelper extends SchemaHelper {
         return checkConstraints.reduce((o, item) => {
             // check constraints are defined as (note that last closing paren is missing):
             // `type` text check (`type` in ('local', 'global')
-            const match = item.match(/[`["']([^`\]"']+)[`\]"'] text check \(.* \((.*)\)/i);
+            const match = /[`["']([^`\]"']+)[`\]"'] text check \(.* \((.*)\)/i.exec(item);
             /* v8 ignore next */
             if (match) {
-                o[match[1]] = match[2].split(',').map((item) => item.trim().match(/^\(?'(.*)'/)[1]);
+                o[match[1]] = match[2].split(',').map((item) => /^\(?'(.*)'/.exec(item.trim())[1]);
             }
             return o;
         }, {});
@@ -371,7 +375,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
         const checks = [];
         for (const key of Object.keys(columns)) {
             const column = columns[key];
-            const expression = column.definition.match(/ (check \((.*)\))/i);
+            const expression = / (check \((.*)\))/i.exec(column.definition);
             if (expression) {
                 checks.push({
                     name: this.platform.getConfig().getNamingStrategy().indexName(tableName, [column.name], 'check'),
@@ -382,7 +386,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
             }
         }
         for (const constraint of constraints) {
-            const expression = constraint.match(/constraint *[`"']?(.*?)[`"']? * (check \((.*)\))/i);
+            const expression = /constraint *[`"']?(.*?)[`"']? * (check \((.*)\))/i.exec(constraint);
             if (expression) {
                 checks.push({
                     name: expression[1],

package/index.d.ts

@@ -13,7 +13,7 @@ export * from './query/index.js';
 export { raw } from './query/index.js';
 export * from './schema/index.js';
 export * from './dialects/index.js';
-export * from './typings.js';
+export type * from './typings.js';
 export * from './plugin/index.js';
 export { SqlEntityManager as EntityManager } from './SqlEntityManager.js';
 export { SqlEntityRepository as EntityRepository } from './SqlEntityRepository.js';

package/index.js

@@ -13,7 +13,6 @@ export * from './query/index.js';
 export { raw } from './query/index.js';
 export * from './schema/index.js';
 export * from './dialects/index.js';
-export * from './typings.js';
 export * from './plugin/index.js';
 export { SqlEntityManager as EntityManager } from './SqlEntityManager.js';
 export { SqlEntityRepository as EntityRepository } from './SqlEntityRepository.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-rc.3",
+  "version": "7.0.1-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",
@@ -50,10 +50,10 @@
     "kysely": "0.28.11"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^6.6.8"
+    "@mikro-orm/core": "^7.0.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-rc.3"
+    "@mikro-orm/core": "7.0.1-dev.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;