@mikro-orm/mssql 7.1.0-dev.43 → 7.1.0-dev.45

package/MsSqlConnection.d.ts

@@ -1,10 +1,12 @@
 import { AbstractSqlConnection, type TransactionEventBroadcaster } from '@mikro-orm/sql';
 import { type ControlledTransaction, MssqlDialect } from 'kysely';
+import { type Routine, type Transaction } from '@mikro-orm/core';
 import type { ConnectionConfiguration } from 'tedious';
 /** Microsoft SQL Server database connection using the `tedious` driver. */
 export declare class MsSqlConnection extends AbstractSqlConnection {
     createKyselyDialect(overrides: ConnectionConfiguration): MssqlDialect;
     private mapOptions;
+    callRoutine<T>(routine: Routine, args?: Record<string, unknown>, ctx?: Transaction): Promise<T>;
     commit(ctx: ControlledTransaction<any, any>, eventBroadcaster?: TransactionEventBroadcaster): Promise<void>;
     protected transformRawResult<T>(res: any, method: 'all' | 'get' | 'run'): T;
 }

package/MsSqlConnection.js

@@ -1,4 +1,4 @@
-import { AbstractSqlConnection, Utils } from '@mikro-orm/sql';
+import { AbstractSqlConnection, DatabaseSchema, Utils, } from '@mikro-orm/sql';
 import { MssqlDialect } from 'kysely';
 import * as Tedious from 'tedious';
 import * as Tarn from 'tarn';
@@ -55,6 +55,53 @@ export class MsSqlConnection extends AbstractSqlConnection {
         }
         return Utils.mergeConfig(ret, overrides);
     }
+    async callRoutine(routine, args = {}, ctx) {
+        if (routine.type === 'function') {
+            return this.callRoutineFunction(routine, args, ctx);
+        }
+        // MSSQL scalar UDF calls must be schema-qualified — `select sql_hash(...)` fails to parse.
+        const schema = routine.schema ?? this.platform.getDefaultSchemaName() ?? 'dbo';
+        const qualified = `${this.platform.quoteIdentifier(schema)}.${this.platform.quoteIdentifier(routine.name)}`;
+        // T-SQL session variables don't persist across execute() calls (different pool connections),
+        // so DECLARE/SET/EXEC/SELECT must go through as a single batch.
+        const declareLines = [];
+        const setLines = [];
+        const setValues = [];
+        const callArgs = [];
+        const inValues = [];
+        const outVars = [];
+        routine.params.forEach((p, i) => {
+            if (p.direction === 'in') {
+                callArgs.push('?');
+                inValues.push(this.convertRoutineInbound(args[p.name], p));
+                return;
+            }
+            const varName = `@_mikro_orm_routine_${i}`;
+            // Logical aliases like `'string'`/`'number'` aren't valid T-SQL types — translate them
+            // through the platform's type system, matching the DDL side in `DatabaseSchema`.
+            const declType = DatabaseSchema.resolveRoutineColumnType(p.type, this.platform);
+            declareLines.push(`declare ${varName} ${declType}`);
+            outVars.push({ name: p.name, varName, param: p });
+            if (p.direction === 'inout') {
+                setLines.push(`set ${varName} = ?`);
+                setValues.push(this.convertRoutineInbound(args[p.name], p));
+            }
+            callArgs.push(`${varName} output`);
+        });
+        const allValues = [...setValues, ...inValues];
+        const batch = [...declareLines, ...setLines, `exec ${qualified} ${callArgs.join(', ')}`];
+        if (outVars.length > 0) {
+            const selectClause = outVars.map(o => `${o.varName} as ${this.platform.quoteIdentifier(o.name)}`).join(', ');
+            batch.push(`select ${selectClause}`);
+        }
+        const result = await this.execute(batch.join('; '), allValues, 'all', ctx);
+        if (outVars.length === 0) {
+            return undefined;
+        }
+        const rows = result;
+        this.applyRoutineOutParams(rows[0] ?? {}, outVars.map(o => o.param), args);
+        return undefined;
+    }
     async commit(ctx, eventBroadcaster) {
         if ('savepointName' in ctx) {
             return;

package/MsSqlSchemaHelper.d.ts

@@ -1,4 +1,4 @@
-import { type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type Dictionary, type ForeignKey, type IndexDef, SchemaHelper, type Table, type TableDifference, type SqlTriggerDef, type Transaction, type Type } from '@mikro-orm/sql';
+import { type AbstractSqlConnection, type CheckDef, type Column, type DatabaseSchema, type DatabaseTable, type Dictionary, type ForeignKey, type IndexDef, SchemaHelper, type Table, type TableDifference, type SqlTriggerDef, type SqlRoutineDef, type Transaction, type Type } from '@mikro-orm/sql';
 /** Schema introspection helper for Microsoft SQL Server. */
 export declare class MsSqlSchemaHelper extends SchemaHelper {
     static readonly DEFAULT_VALUES: {
@@ -29,6 +29,14 @@ export declare class MsSqlSchemaHelper extends SchemaHelper {
     createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
     /** Generates SQL to drop an MSSQL trigger. */
     dropTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    routineParamReference(name: string): string;
+    /** T-SQL's `OUTPUT` covers both OUT and INOUT; `sys.parameters.is_output` is true for both. */
+    normaliseRoutineParamDirection(direction: 'in' | 'out' | 'inout'): 'in' | 'out' | 'inout';
+    createRoutine(routine: SqlRoutineDef): string;
+    dropRoutine(routine: SqlRoutineDef): string;
+    getAllRoutines(connection: AbstractSqlConnection): Promise<SqlRoutineDef[]>;
+    private getAllRoutineParams;
+    private unwrapMsSqlBody;
     private getSchemaQualifiedName;
     getDatabaseCollation(connection: AbstractSqlConnection, ctx?: Transaction): Promise<string | undefined>;
     getAllTriggers(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<SqlTriggerDef[]>>;

package/MsSqlSchemaHelper.js

@@ -353,6 +353,113 @@ export class MsSqlSchemaHelper extends SchemaHelper {
     dropTrigger(table, trigger) {
         return `drop trigger if exists ${this.getSchemaQualifiedName(table, trigger.name)}`;
     }
+    routineParamReference(name) {
+        return `@${name}`;
+    }
+    /** T-SQL's `OUTPUT` covers both OUT and INOUT; `sys.parameters.is_output` is true for both. */
+    normaliseRoutineParamDirection(direction) {
+        return direction === 'out' ? 'inout' : direction;
+    }
+    createRoutine(routine) {
+        if (routine.expression) {
+            return routine.expression;
+        }
+        const qualifiedName = this.qualifiedRoutineName(routine);
+        const params = routine.params
+            .map(p => {
+            const dir = p.direction === 'out' || p.direction === 'inout' ? ' OUTPUT' : '';
+            return `@${p.name} ${p.type}${dir}`;
+        })
+            .join(', ');
+        const body = this.wrapRoutineBody(routine.body ?? '');
+        if (routine.type === 'procedure') {
+            return `create or alter procedure ${qualifiedName} ${params} as ${body}`;
+        }
+        const returnType = routine.returns?.type ?? 'nvarchar(max)';
+        return `create or alter function ${qualifiedName}(${params}) returns ${returnType} as ${body}`;
+    }
+    dropRoutine(routine) {
+        const kind = routine.type === 'procedure' ? 'procedure' : 'function';
+        return `drop ${kind} if exists ${this.qualifiedRoutineName(routine)}`;
+    }
+    async getAllRoutines(connection) {
+        const sql = `
+      select
+        s.name as schema_name,
+        o.name as name,
+        case
+          when o.type = 'P' then 'procedure'
+          when o.type in ('FN', 'IF', 'TF') then 'function'
+        end as kind,
+        m.definition as definition,
+        ep.value as comment
+      from sys.objects o
+      join sys.schemas s on s.schema_id = o.schema_id
+      join sys.sql_modules m on m.object_id = o.object_id
+      left join sys.extended_properties ep
+        on ep.major_id = o.object_id and ep.minor_id = 0 and ep.name = 'MS_Description'
+      where o.type in ('P', 'FN', 'IF', 'TF')
+        and o.is_ms_shipped = 0
+    `;
+        const [rows, paramsAndReturns] = await Promise.all([
+            connection.execute(sql),
+            this.getAllRoutineParams(connection),
+        ]);
+        const { params, returns } = paramsAndReturns;
+        return rows.map(row => ({
+            name: row.name,
+            schema: row.schema_name,
+            type: row.kind,
+            body: this.unwrapMsSqlBody(row.definition),
+            comment: row.comment ?? undefined,
+            params: params.get(`${row.schema_name}.${row.name}`) ?? [],
+            returns: row.kind === 'function'
+                ? (returns.get(`${row.schema_name}.${row.name}`) ?? { type: 'nvarchar(max)', nullable: true })
+                : undefined,
+        }));
+    }
+    async getAllRoutineParams(connection) {
+        // `parameter_id = 0` is the function's return type; positive IDs are formal parameters.
+        const sql = `
+      select
+        s.name as schema_name,
+        o.name as routine_name,
+        p.name as param_name,
+        type_name(p.user_type_id) as type,
+        p.is_output as is_output,
+        p.parameter_id as position
+      from sys.parameters p
+      join sys.objects o on o.object_id = p.object_id
+      join sys.schemas s on s.schema_id = o.schema_id
+      where o.type in ('P', 'FN', 'IF', 'TF')
+        and o.is_ms_shipped = 0
+      order by o.object_id, p.parameter_id
+    `;
+        const rows = await connection.execute(sql);
+        const params = new Map();
+        const returns = new Map();
+        for (const row of rows) {
+            const key = `${row.schema_name}.${row.routine_name}`;
+            if (row.position === 0) {
+                returns.set(key, { type: row.type, nullable: true });
+                continue;
+            }
+            if (!params.has(key)) {
+                params.set(key, []);
+            }
+            // is_output is true for both OUT and INOUT; we always report `inout`. See normaliseRoutineParamDirection.
+            params.get(key).push({
+                name: row.param_name.replace(/^@/, ''),
+                type: row.type,
+                direction: row.is_output ? 'inout' : 'in',
+            });
+        }
+        return { params, returns };
+    }
+    unwrapMsSqlBody(definition) {
+        const asMatch = /\bas\s+([\s\S]*)$/i.exec(definition);
+        return this.stripRoutineBody(asMatch ? asMatch[1] : definition);
+    }
     getSchemaQualifiedName(table, name) {
         const defaultSchema = this.platform.getDefaultSchemaName();
         if (table.schema && table.schema !== defaultSchema) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/mssql",
-  "version": "7.1.0-dev.43",
+  "version": "7.1.0-dev.45",
   "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,7 +47,7 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/sql": "7.1.0-dev.43",
+    "@mikro-orm/sql": "7.1.0-dev.45",
     "kysely": "0.29.2",
     "tarn": "3.0.2",
     "tedious": "19.2.1",
@@ -57,7 +57,7 @@
     "@mikro-orm/core": "^7.0.17"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.43"
+    "@mikro-orm/core": "7.1.0-dev.45"
   },
   "engines": {
     "node": ">= 22.17.0"