@mikro-orm/sql 7.1.0-dev.42 → 7.1.0-dev.44

package/dialects/mysql/MySqlSchemaHelper.d.ts

@@ -1,5 +1,5 @@
 import { type Dictionary, type Transaction, type Type } from '@mikro-orm/core';
-import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef } from '../../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef, SqlRoutineDef } from '../../typings.js';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
@@ -41,6 +41,12 @@ export declare class MySqlSchemaHelper extends SchemaHelper {
     getAllChecks(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<CheckDef[]>>;
     /** Generates SQL to create MySQL triggers. MySQL requires one trigger per event. */
     createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    createRoutine(routine: SqlRoutineDef): string;
+    dropRoutine(routine: SqlRoutineDef): string;
+    getAllRoutines(connection: AbstractSqlConnection): Promise<SqlRoutineDef[]>;
+    private getAllRoutineParams;
+    private formatDataAccess;
+    private parseDataAccess;
     getAllTriggers(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<SqlTriggerDef[]>>;
     getAllForeignKeys(connection: AbstractSqlConnection, tables: Table[], ctx?: Transaction): Promise<Dictionary<Dictionary<ForeignKey>>>;
     getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];

package/dialects/mysql/MySqlSchemaHelper.js

@@ -325,6 +325,115 @@ export class MySqlSchemaHelper extends SchemaHelper {
         }
         return ret.join(';\n');
     }
+    createRoutine(routine) {
+        if (routine.expression) {
+            return routine.expression;
+        }
+        const name = this.platform.quoteIdentifier(routine.name);
+        // MySQL functions reject direction prefixes (function params are always IN); procedures use them.
+        const params = routine.params
+            .map(p => {
+            const dir = routine.type === 'procedure' ? `${p.direction.toUpperCase()} ` : '';
+            return `${dir}${this.platform.quoteIdentifier(p.name)} ${p.type}`;
+        })
+            .join(', ');
+        const determinism = routine.deterministic === true ? ' deterministic' : routine.deterministic === false ? ' not deterministic' : '';
+        const dataAccess = this.formatDataAccess(routine.dataAccess);
+        const security = routine.security === 'definer'
+            ? ' sql security definer'
+            : routine.security === 'invoker'
+                ? ' sql security invoker'
+                : '';
+        const comment = routine.comment ? ` comment ${this.platform.quoteValue(routine.comment)}` : '';
+        const body = this.wrapRoutineBody(routine.body ?? '');
+        if (routine.type === 'procedure') {
+            return `create procedure ${name}(${params})${determinism}${dataAccess}${security}${comment} ${body}`;
+        }
+        const returnType = routine.returns?.type ?? 'text';
+        return `create function ${name}(${params}) returns ${returnType}${determinism}${dataAccess}${security}${comment} ${body}`;
+    }
+    dropRoutine(routine) {
+        const kind = routine.type === 'procedure' ? 'procedure' : 'function';
+        return `drop ${kind} if exists ${this.platform.quoteIdentifier(routine.name)}`;
+    }
+    async getAllRoutines(connection) {
+        const sql = `
+      select
+        r.routine_name as name,
+        r.routine_schema as schema_name,
+        lower(r.routine_type) as type,
+        r.routine_definition as body,
+        r.dtd_identifier as return_type,
+        r.is_deterministic as is_deterministic,
+        r.sql_data_access as sql_data_access,
+        r.security_type as security_type,
+        r.routine_comment as comment
+      from information_schema.routines r
+      where r.routine_schema = database()
+        and r.routine_type in ('PROCEDURE', 'FUNCTION')
+    `;
+        const [rows, params] = await Promise.all([
+            connection.execute(sql),
+            this.getAllRoutineParams(connection),
+        ]);
+        return rows.map(row => ({
+            name: row.name,
+            type: row.type,
+            // MySQL has no schema namespace for routines — undefined matches the metadata side.
+            schema: undefined,
+            body: this.stripRoutineBody(row.body ?? ''),
+            deterministic: row.is_deterministic === 'YES',
+            dataAccess: this.parseDataAccess(row.sql_data_access),
+            security: row.security_type === 'DEFINER' ? 'definer' : 'invoker',
+            comment: row.comment || undefined,
+            params: params.get(row.name) ?? [],
+            returns: row.type === 'function' && row.return_type ? { type: row.return_type } : undefined,
+        }));
+    }
+    async getAllRoutineParams(connection) {
+        const sql = `
+      select
+        specific_name as routine_name,
+        parameter_name as name,
+        parameter_mode as direction,
+        dtd_identifier as type,
+        ordinal_position as position
+      from information_schema.parameters
+      where specific_schema = database()
+        and parameter_name is not null
+      order by specific_name, ordinal_position
+    `;
+        const rows = await connection.execute(sql);
+        const out = new Map();
+        for (const row of rows) {
+            if (!out.has(row.routine_name)) {
+                out.set(row.routine_name, []);
+            }
+            out.get(row.routine_name).push({
+                name: row.name,
+                type: row.type,
+                direction: row.direction.toLowerCase(),
+            });
+        }
+        return out;
+    }
+    formatDataAccess(access) {
+        switch (access) {
+            case 'no-sql':
+                return ' no sql';
+            case 'reads-sql-data':
+                return ' reads sql data';
+            case 'modifies-sql-data':
+                return ' modifies sql data';
+            case 'contains-sql':
+                return ' contains sql';
+            default:
+                return '';
+        }
+    }
+    parseDataAccess(access) {
+        return access.toLowerCase().replace(/\s+/g, '-');
+    }
     async getAllTriggers(connection, tables) {
         const names = tables.map(t => this.platform.quoteValue(t.table_name)).join(', ');
         const sql = `select trigger_name as trigger_name, event_object_table as table_name, nullif(event_object_schema, schema()) as schema_name,

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -1,7 +1,7 @@
 import { type Dictionary, type Transaction } from '@mikro-orm/core';
 import { SchemaHelper } from '../../schema/SchemaHelper.js';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
-import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, TablePartitioning, SqlTriggerDef } from '../../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, TablePartitioning, SqlTriggerDef, SqlRoutineDef } from '../../typings.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
 import type { DatabaseTable } from '../../schema/DatabaseTable.js';
 export declare class PostgreSqlSchemaHelper extends SchemaHelper {
@@ -69,6 +69,13 @@ export declare class PostgreSqlSchemaHelper extends SchemaHelper {
     createTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
     /** Generates SQL to drop a PostgreSQL trigger and its associated function. */
     dropTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    createRoutine(routine: SqlRoutineDef): string;
+    dropRoutine(routine: SqlRoutineDef): string;
+    getAllRoutines(connection: AbstractSqlConnection, schemas?: string[]): Promise<SqlRoutineDef[]>;
+    private formatRoutineParams;
+    private parseRoutineParams;
+    /** PG canonicalises `$$` quoting to a tagged form like `$function$ ... $function$`; match the tag-aware form. */
+    private extractRoutineBody;
     private getSchemaQualifiedTriggerFnName;
     /**
      * Resolves the real name of the implicit 'default' collation (the DB's `datcollate`),

package/dialects/postgresql/PostgreSqlSchemaHelper.js

@@ -1,5 +1,5 @@
 import { DeferMode, EnumType, Type, Utils, } from '@mikro-orm/core';
-import { SchemaHelper } from '../../schema/SchemaHelper.js';
+import { SchemaHelper, stripStatementNewlines } from '../../schema/SchemaHelper.js';
 import { normalizePartitionBound, normalizePartitionDefinition } from '../../schema/partitioning.js';
 /** PostGIS system views that should be automatically ignored */
 const POSTGIS_VIEWS = ['geography_columns', 'geometry_columns'];
@@ -362,7 +362,6 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
                 }
             }
         }
-        /* v8 ignore next - pg_get_indexdef always returns balanced parentheses */
         return '';
     }
     async getAllColumns(connection, tablesBySchemas, nativeEnums, ctx) {
@@ -512,6 +511,118 @@ export class PostgreSqlSchemaHelper extends SchemaHelper {
         const fnName = this.getSchemaQualifiedTriggerFnName(table, trigger);
         return `drop trigger if exists ${triggerName} on ${table.getQuotedName()};\ndrop function if exists ${fnName}()`;
     }
+    createRoutine(routine) {
+        if (routine.expression) {
+            return routine.expression;
+        }
+        const qualifiedName = this.qualifiedRoutineName(routine);
+        const params = this.formatRoutineParams(routine);
+        // Default `sql` for functions, `plpgsql` for procedures (block syntax required).
+        const language = (routine.language ?? (routine.type === 'procedure' ? 'plpgsql' : 'sql')).toLowerCase();
+        const security = routine.security === 'definer' ? ' security definer' : routine.security === 'invoker' ? ' security invoker' : '';
+        const determinism = routine.deterministic === true ? ' immutable' : routine.deterministic === false ? ' volatile' : '';
+        const flatten = (s) => stripStatementNewlines(s).trim();
+        if (routine.type === 'procedure') {
+            const body = language === 'sql' ? flatten(routine.body ?? '') : this.wrapRoutineBody(routine.body ?? '');
+            return `create or replace procedure ${qualifiedName}(${params})${security} language ${language} as $$ ${body} $$`;
+        }
+        const returnType = routine.returns?.type ?? 'void';
+        const body = language === 'sql' ? flatten(routine.body ?? '') : this.wrapRoutineBody(routine.body ?? '');
+        return `create or replace function ${qualifiedName}(${params}) returns ${returnType}${security}${determinism} language ${language} as $$ ${body} $$`;
+    }
+    dropRoutine(routine) {
+        const qualifiedName = this.qualifiedRoutineName(routine);
+        const argTypes = routine.params.map(p => p.type).join(', ');
+        const kind = routine.type === 'procedure' ? 'procedure' : 'function';
+        return `drop ${kind} if exists ${qualifiedName}(${argTypes})`;
+    }
+    async getAllRoutines(connection, schemas = []) {
+        const target = (schemas.length > 0 ? schemas : [this.platform.getDefaultSchemaName()]).filter(Boolean);
+        const schemaList = target.map(s => this.platform.quoteValue(s)).join(', ');
+        const sql = `
+      select
+        n.nspname as schema_name,
+        p.proname as name,
+        case when p.prokind = 'p' then 'procedure' else 'function' end as kind,
+        l.lanname as language,
+        case when p.proisstrict then false else null end as is_strict,
+        case when p.provolatile = 'i' then true when p.provolatile = 'v' then false else null end as deterministic,
+        case when p.prosecdef then 'definer' else 'invoker' end as security,
+        pg_get_functiondef(p.oid) as full_def,
+        pg_get_function_arguments(p.oid) as arg_signature,
+        pg_get_function_result(p.oid) as result_type,
+        d.description as comment
+      from pg_proc p
+      join pg_namespace n on n.oid = p.pronamespace
+      join pg_language l on l.oid = p.prolang
+      left join pg_description d on d.objoid = p.oid and d.classoid = 'pg_proc'::regclass
+      where n.nspname in (${schemaList})
+        and l.lanname not in ('c', 'internal')
+        -- exclude functions owned by extensions (PostGIS et al.)
+        and not exists (
+          select 1 from pg_depend dep
+          where dep.objid = p.oid
+            and dep.classid = 'pg_proc'::regclass
+            and dep.deptype = 'e'
+        )
+        -- exclude trigger-helper functions; they're managed alongside their owning trigger.
+        and p.prorettype <> 'trigger'::regtype
+    `;
+        const rows = await connection.execute(sql);
+        return rows.map(row => {
+            const params = this.parseRoutineParams(row.arg_signature);
+            const body = this.extractRoutineBody(row.full_def);
+            return {
+                name: row.name,
+                schema: row.schema_name,
+                type: row.kind,
+                language: row.language,
+                comment: row.comment ?? undefined,
+                security: row.security,
+                deterministic: row.deterministic ?? undefined,
+                body,
+                params,
+                returns: row.kind === 'function' && row.result_type ? { type: row.result_type, nullable: true } : undefined,
+            };
+        });
+    }
+    formatRoutineParams(routine) {
+        return routine.params
+            .map(p => {
+            const dir = p.direction === 'in' ? '' : `${p.direction.toUpperCase()} `;
+            const def = p.defaultRaw ? ` default ${p.defaultRaw}` : '';
+            return `${dir}${this.platform.quoteIdentifier(p.name)} ${p.type}${def}`;
+        })
+            .join(', ');
+    }
+    parseRoutineParams(signature) {
+        if (!signature.trim()) {
+            return [];
+        }
+        return signature.split(/,(?![^()]*\))/).map(part => {
+            const trimmed = part.trim();
+            // INOUT before IN/OUT, with required trailing space so identifiers like `input` aren't
+            // mis-parsed as a direction keyword.
+            const match = /^(?:(INOUT|VARIADIC|IN|OUT)\s+)?(?:"((?:[^"]|"")+)"|([\w$]+))\s+(.+?)(?:\s+default\s+.+)?$/i.exec(trimmed);
+            /* v8 ignore next 3: defensive guard for unexpected `pg_get_function_arguments` output shapes */
+            if (!match) {
+                throw new Error(`Could not parse PostgreSQL routine parameter signature: ${JSON.stringify(trimmed)}`);
+            }
+            const dirRaw = (match[1] ?? 'in').toLowerCase();
+            const direction = dirRaw === 'inout' ? 'inout' : dirRaw === 'out' ? 'out' : 'in';
+            const name = match[2] != null ? match[2].replaceAll('""', '"') : match[3];
+            return {
+                name,
+                type: match[4].trim(),
+                direction,
+            };
+        });
+    }
+    /** PG canonicalises `$$` quoting to a tagged form like `$function$ ... $function$`; match the tag-aware form. */
+    extractRoutineBody(fullDef) {
+        const tagged = /\bAS\s+\$(\w*)\$([\s\S]*?)\$\1\$/i.exec(fullDef);
+        return this.stripRoutineBody(tagged ? tagged[2] : fullDef);
+    }
     getSchemaQualifiedTriggerFnName(table, trigger) {
         const rawName = `${table.name}_${trigger.name}_fn`;
         const defaultSchema = this.platform.getDefaultSchemaName();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.1.0-dev.42",
+  "version": "7.1.0-dev.44",
   "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",
@@ -53,7 +53,7 @@
     "@mikro-orm/core": "^7.0.17"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.42"
+    "@mikro-orm/core": "7.1.0-dev.44"
   },
   "engines": {
     "node": ">= 22.17.0"

package/schema/DatabaseSchema.d.ts

@@ -1,7 +1,7 @@
-import { type Configuration, type Dictionary, type EntityMetadata, type Transaction } from '@mikro-orm/core';
+import { type Configuration, type Dictionary, type EntityMetadata, type Routine, type Transaction, type Type } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable.js';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
-import type { DatabaseView } from '../typings.js';
+import type { DatabaseView, SqlRoutineDef } from '../typings.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
 /**
  * @internal
@@ -24,6 +24,8 @@ export declare class DatabaseSchema {
     setViews(views: DatabaseView[]): void;
     getView(name: string): DatabaseView | undefined;
     hasView(name: string): boolean;
+    addRoutine(routine: SqlRoutineDef): SqlRoutineDef;
+    getRoutines(): SqlRoutineDef[];
     setNativeEnums(nativeEnums: Dictionary<{
         name: string;
         schema?: string;
@@ -43,7 +45,32 @@ export declare class DatabaseSchema {
     hasNativeEnum(name: string): boolean;
     getNamespaces(): string[];
     static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[], takeTables?: (string | RegExp)[], skipTables?: (string | RegExp)[], skipViews?: (string | RegExp)[], ctx?: Transaction): Promise<DatabaseSchema>;
+    /** Separate from `create()` so the comparator only pays for routine introspection when the user actually defined routines. SQLite/libSQL helpers return []. */
+    loadRoutines(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, schemas?: string[]): Promise<void>;
     static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, em?: any): DatabaseSchema;
+    /** Separate from {@link fromMetadata} so the comparator only walks routines when the user defined any. */
+    addRoutinesFromMetadata(routines: readonly Routine[], platform: AbstractSqlPlatform, em?: any): void;
+    /**
+     * Normalises a routine's `returns` config to the `{ type, runtimeType, nullable }` shape the
+     * DDL side and introspection-comparator both consume. Supports both `{ type: SomeType }`
+     * (Type drives column + runtime types) and `{ runtimeType, columnType, ... }` (explicit).
+     *
+     * @internal
+     */
+    static normaliseRoutineReturns(returns: Routine['returns'], platform: AbstractSqlPlatform): {
+        type: string;
+        runtimeType: string;
+        nullable?: boolean;
+    } | undefined;
+    /**
+     * Maps a routine param's declared `type` to a dialect-specific SQL column type. A `Type`
+     * instance (when the user passed a `Type` class/instance at `type`) routes through
+     * `Type.getColumnType` so its dialect-aware mapping wins. String aliases (`'string'`,
+     * `'number'`, …) go through the platform's type registry; literal SQL types pass through.
+     *
+     * @internal
+     */
+    static resolveRoutineColumnType(type: string | Type<unknown>, platform: AbstractSqlPlatform): string;
     private static getViewDefinition;
     private static getSchemaName;
     /**

package/schema/DatabaseSchema.js

@@ -8,6 +8,7 @@ export class DatabaseSchema {
     name;
     #tables = [];
     #views = [];
+    #routines = [];
     #namespaces = new Set();
     #nativeEnums = {}; // for postgres
     #platform;
@@ -65,6 +66,16 @@ export class DatabaseSchema {
     hasView(name) {
         return !!this.getView(name);
     }
+    addRoutine(routine) {
+        this.#routines.push(routine);
+        if (routine.schema != null) {
+            this.#namespaces.add(routine.schema);
+        }
+        return routine;
+    }
+    getRoutines() {
+        return this.#routines;
+    }
     setNativeEnums(nativeEnums) {
         this.#nativeEnums = nativeEnums;
         for (const nativeEnum of Object.values(nativeEnums)) {
@@ -111,6 +122,10 @@ export class DatabaseSchema {
         }
         return schema;
     }
+    /** Separate from `create()` so the comparator only pays for routine introspection when the user actually defined routines. SQLite/libSQL helpers return []. */
+    async loadRoutines(connection, platform, schemas = []) {
+        this.#routines = await platform.getSchemaHelper().getAllRoutines(connection, schemas);
+    }
     static fromMetadata(metadata, platform, config, schemaName, em) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema'));
         const nativeEnums = {};
@@ -241,6 +256,110 @@ export class DatabaseSchema {
         }
         return schema;
     }
+    /** Separate from {@link fromMetadata} so the comparator only walks routines when the user defined any. */
+    addRoutinesFromMetadata(routines, platform, em) {
+        const resolveBody = (raw) => {
+            if (raw == null) {
+                return undefined;
+            }
+            if (typeof raw === 'string') {
+                return raw;
+            }
+            if (isRaw(raw)) {
+                return platform.formatQuery(raw.sql, raw.params);
+            }
+            return undefined;
+        };
+        const helper = platform.getSchemaHelper();
+        for (const routine of routines) {
+            const paramMap = routine.params.reduce((o, p) => {
+                o[p.name] = helper.routineParamReference(p.name);
+                return o;
+            }, {});
+            const evaluated = typeof routine.body === 'function' ? routine.body(paramMap, em) : routine.body;
+            const body = resolveBody(evaluated);
+            const returns = DatabaseSchema.normaliseRoutineReturns(routine.returns, platform);
+            this.addRoutine({
+                name: routine.name,
+                // MySQL has no schema namespace for routines, so leave undefined to align with the introspection side.
+                schema: routine.schema ?? (platform.getDefaultSchemaName() != null ? this.name : undefined),
+                type: routine.type,
+                language: routine.language,
+                comment: routine.comment,
+                security: routine.security,
+                definer: routine.definer,
+                deterministic: routine.deterministic,
+                dataAccess: routine.dataAccess,
+                body,
+                expression: routine.expression,
+                ignoreSchemaChanges: routine.ignoreSchemaChanges,
+                params: routine.params.map(p => ({
+                    name: p.name,
+                    type: DatabaseSchema.resolveRoutineColumnType(p.type, platform),
+                    direction: helper.normaliseRoutineParamDirection(p.direction),
+                    nullable: p.nullable,
+                    defaultRaw: p.defaultRaw,
+                })),
+                returns,
+            });
+        }
+    }
+    /**
+     * Normalises a routine's `returns` config to the `{ type, runtimeType, nullable }` shape the
+     * DDL side and introspection-comparator both consume. Supports both `{ type: SomeType }`
+     * (Type drives column + runtime types) and `{ runtimeType, columnType, ... }` (explicit).
+     *
+     * @internal
+     */
+    static normaliseRoutineReturns(returns, platform) {
+        if (!returns || typeof returns !== 'object') {
+            return undefined;
+        }
+        if ('runtimeType' in returns) {
+            return {
+                type: (returns.columnType ?? returns.runtimeType),
+                runtimeType: returns.runtimeType,
+                nullable: returns.nullable,
+            };
+        }
+        if ('type' in returns && returns.type) {
+            const instance = typeof returns.type === 'function' ? new returns.type() : returns.type;
+            return {
+                type: DatabaseSchema.resolveRoutineColumnType(instance, platform),
+                runtimeType: instance.runtimeType,
+                nullable: returns.nullable,
+            };
+        }
+        return undefined;
+    }
+    /**
+     * Maps a routine param's declared `type` to a dialect-specific SQL column type. A `Type`
+     * instance (when the user passed a `Type` class/instance at `type`) routes through
+     * `Type.getColumnType` so its dialect-aware mapping wins. String aliases (`'string'`,
+     * `'number'`, …) go through the platform's type registry; literal SQL types pass through.
+     *
+     * @internal
+     */
+    static resolveRoutineColumnType(type, platform) {
+        if (typeof type !== 'string') {
+            return type.getColumnType({ columnTypes: [], runtimeType: 'any' }, platform);
+        }
+        const lower = type.toLowerCase();
+        const aliases = {
+            string: 'string',
+            number: 'integer',
+            bigint: 'bigint',
+            boolean: 'boolean',
+            date: 'datetime',
+            buffer: 'blob',
+        };
+        const mappedKey = aliases[lower];
+        if (!mappedKey) {
+            return type;
+        }
+        const t = platform.getMappedType(mappedKey);
+        return t.getColumnType({ type: mappedKey, length: undefined }, platform);
+    }
     static getViewDefinition(meta, em, platform) {
         if (typeof meta.expression === 'string') {
             return meta.expression;

package/schema/SchemaComparator.d.ts

@@ -17,6 +17,15 @@ export declare class SchemaComparator {
      * stored in toSchema.
      */
     compare(fromSchema: DatabaseSchema, toSchema: DatabaseSchema, inverseDiff?: SchemaDifference): SchemaDifference;
+    private compareRoutines;
+    private diffRoutine;
+    /** Strips outer `BEGIN ... END` and trailing semicolons so the comparator doesn't churn on cosmetic round-trip differences. */
+    private normaliseBody;
+    private diffRoutineParams;
+    /** Engines drop length/precision modifiers and use different aliases for the same logical type — canonicalise both sides. */
+    private normaliseParamType;
+    private static readonly PARAM_TYPE_ALIASES;
+    private diffRoutineReturns;
     /**
      * Returns the difference between the tables fromTable and toTable.
      * If there are no differences this method returns the boolean false.

package/schema/SchemaComparator.js

@@ -28,6 +28,9 @@ export class SchemaComparator {
             newViews: {},
             changedViews: {},
             removedViews: {},
+            newRoutines: {},
+            changedRoutines: {},
+            removedRoutines: {},
             orphanedForeignKeys: [],
             newNativeEnums: [],
             removedNativeEnums: [],
@@ -163,8 +166,151 @@ export class SchemaComparator {
                 diff.changedTables[viewName] = tableDiff;
             }
         }
+        this.compareRoutines(fromSchema, toSchema, diff);
         return diff;
     }
+    compareRoutines(fromSchema, toSchema, diff) {
+        // Case-fold so user-written `'sql_hash'` matches Oracle's introspected `'SQL_HASH'`.
+        const routineKey = (r) => ((r.schema ? `${r.schema}.` : '') + r.name).toLowerCase();
+        const fromByKey = new Map(fromSchema.getRoutines().map(r => [routineKey(r), r]));
+        const toByKey = new Map(toSchema.getRoutines().map(r => [routineKey(r), r]));
+        for (const [key, toRoutine] of toByKey) {
+            const fromRoutine = fromByKey.get(key);
+            if (!fromRoutine) {
+                diff.newRoutines[key] = toRoutine;
+                this.log(`routine ${key} added`);
+                continue;
+            }
+            if (this.diffRoutine(fromRoutine, toRoutine)) {
+                diff.changedRoutines[key] = { from: fromRoutine, to: toRoutine };
+                this.log(`routine ${key} changed`, { fromRoutine, toRoutine });
+            }
+        }
+        for (const [key, fromRoutine] of fromByKey) {
+            if (!toByKey.has(key)) {
+                diff.removedRoutines[key] = fromRoutine;
+                this.log(`routine ${key} removed`);
+            }
+        }
+    }
+    diffRoutine(from, to) {
+        const ignore = new Set(to.ignoreSchemaChanges ?? []);
+        if (from.type !== to.type) {
+            this.log(`routine ${from.name}: type ${from.type} -> ${to.type}`);
+            return true;
+        }
+        if (!ignore.has('body') && from.expression == null && to.expression == null) {
+            const a = this.normaliseBody(from.body);
+            const b = this.normaliseBody(to.body);
+            if (a !== b) {
+                this.log(`routine ${from.name}: body differs`, { from: a, to: b });
+                return true;
+            }
+        }
+        if (!ignore.has('comment') && (from.comment ?? '') !== (to.comment ?? '')) {
+            return true;
+        }
+        // For security/deterministic/definer, unset on the metadata side means "don't care": the
+        // DB always has some server default, comparing it would force a drop+create on every run.
+        if (!ignore.has('security') && to.security != null && from.security !== to.security) {
+            return true;
+        }
+        if (!ignore.has('deterministic') &&
+            to.deterministic != null &&
+            (from.deterministic ?? false) !== to.deterministic) {
+            return true;
+        }
+        if (!ignore.has('definer') && to.definer != null && from.definer !== to.definer) {
+            return true;
+        }
+        // `language` (PG) / `dataAccess` (MySQL) follow the same to-side-wins policy: only diff when
+        // the metadata explicitly declares them, otherwise the create DDL's defaults will line up with
+        // whatever the engine introspected.
+        if (to.language != null && (from.language ?? '').toLowerCase() !== to.language.toLowerCase()) {
+            this.log(`routine ${from.name}: language ${from.language} -> ${to.language}`);
+            return true;
+        }
+        if (to.dataAccess != null && from.dataAccess !== to.dataAccess) {
+            this.log(`routine ${from.name}: dataAccess ${from.dataAccess} -> ${to.dataAccess}`);
+            return true;
+        }
+        if (this.diffRoutineParams(from.params, to.params)) {
+            this.log(`routine ${from.name}: params differ`, { from: from.params, to: to.params });
+            return true;
+        }
+        if (this.diffRoutineReturns(from.returns, to.returns)) {
+            this.log(`routine ${from.name}: returns differ`, { from: from.returns, to: to.returns });
+            return true;
+        }
+        return false;
+    }
+    /** Strips outer `BEGIN ... END` and trailing semicolons so the comparator doesn't churn on cosmetic round-trip differences. */
+    normaliseBody(body) {
+        let result = (body ?? '').replace(/\s+/g, ' ').trim();
+        const beginEnd = /^begin\s+([\s\S]*?)\s*end\s*;?\s*$/i.exec(result);
+        if (beginEnd) {
+            result = beginEnd[1].trim();
+        }
+        return result.replace(/;+\s*$/, '').trim();
+    }
+    diffRoutineParams(from, to) {
+        if (from.length !== to.length) {
+            return true;
+        }
+        for (let i = 0; i < from.length; i++) {
+            const a = from[i];
+            const b = to[i];
+            if (a.name.toLowerCase() !== b.name.toLowerCase() ||
+                this.normaliseParamType(a.type) !== this.normaliseParamType(b.type) ||
+                a.direction !== b.direction) {
+                return true;
+            }
+            // Asymmetric: drivers don't currently introspect param nullability, so the from side is
+            // always undefined; comparing eagerly would churn metadata-declared `nullable: true`.
+            if (a.nullable != null && !!a.nullable !== !!b.nullable) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /** Engines drop length/precision modifiers and use different aliases for the same logical type — canonicalise both sides. */
+    normaliseParamType(type) {
+        const lengthMatch = /^([^()]+)\(([^)]*)\)\s*$/.exec(type);
+        const base = (lengthMatch ? lengthMatch[1] : type).trim().toLowerCase();
+        const aliased = SchemaComparator.PARAM_TYPE_ALIASES[base] ?? base;
+        const length = lengthMatch ? Number.parseInt(lengthMatch[2].split(',')[0].trim(), 10) : NaN;
+        const options = Number.isFinite(length) ? { length } : {};
+        return this.#platform.normalizeColumnType(aliased, options).toLowerCase();
+    }
+    static PARAM_TYPE_ALIASES = {
+        int: 'integer',
+        int4: 'integer',
+        int8: 'bigint',
+        int2: 'smallint',
+        bool: 'boolean',
+        'character varying': 'varchar',
+        bpchar: 'char',
+        float8: 'double precision',
+        float4: 'real',
+        // Oracle's USER_ARGUMENTS reports `REF CURSOR`; users declare `sys_refcursor`.
+        'ref cursor': 'sys_refcursor',
+    };
+    diffRoutineReturns(from, to) {
+        if (from == null && to == null) {
+            return false;
+        }
+        if (from == null || to == null) {
+            return true;
+        }
+        if (this.normaliseParamType(from.type) !== this.normaliseParamType(to.type)) {
+            return true;
+        }
+        // Engines report function returns as nullable; only diff when metadata explicitly declares it.
+        if (to.nullable != null && (from.nullable ?? false) !== to.nullable) {
+            return true;
+        }
+        return false;
+    }
     /**
      * Returns the difference between the tables fromTable and toTable.
      * If there are no differences this method returns the boolean false.

package/schema/SchemaHelper.d.ts

@@ -1,9 +1,11 @@
 import { type Connection, type Dictionary, type Options, type Transaction, type RawQueryFragment } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
-import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef } from '../typings.js';
+import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference, SqlTriggerDef, SqlRoutineDef } from '../typings.js';
 import type { DatabaseSchema } from './DatabaseSchema.js';
 import type { DatabaseTable } from './DatabaseTable.js';
+/** Flattens `;\n` boundaries so the schema-generator's statement splitter doesn't break the routine DDL apart. Other whitespace is preserved. */
+export declare function stripStatementNewlines(body: string): string;
 /** Base class for database-specific schema helpers. Provides SQL generation for DDL operations. */
 export declare abstract class SchemaHelper {
     protected readonly platform: AbstractSqlPlatform;
@@ -146,6 +148,18 @@ export declare abstract class SchemaHelper {
      * Override in driver-specific helpers for custom DDL.
      */
     dropTrigger(table: DatabaseTable, trigger: SqlTriggerDef): string;
+    /** Default no-op so SQLite/libSQL silent-skip routine DDL; routine-capable dialects override. */
+    createRoutine(_routine: SqlRoutineDef): string;
+    dropRoutine(_routine: SqlRoutineDef): string;
+    getAllRoutines(_connection: AbstractSqlConnection, _schemas?: string[]): Promise<SqlRoutineDef[]>;
+    /** Wraps the body in `BEGIN ... END` if not already, and flattens internal `;\n` so the schema-generator's statement splitter doesn't tear the DDL. */
+    protected wrapRoutineBody(body: string): string;
+    protected stripRoutineBody(body: string): string;
+    /** T-SQL requires `@name` inside the body; PG/MySQL/Oracle use the bare name. */
+    routineParamReference(name: string): string;
+    /** T-SQL doesn't distinguish `OUT` from `INOUT` in the catalog — overrides fold `'out'` into `'inout'`. */
+    normaliseRoutineParamDirection(direction: 'in' | 'out' | 'inout'): 'in' | 'out' | 'inout';
+    protected qualifiedRoutineName(routine: SqlRoutineDef): string;
     /** @internal */
     getTableName(table: string, schema?: string): string;
     getTablesGroupedBySchemas(tables: Table[]): Map<string | undefined, Table[]>;

package/schema/SchemaHelper.js

@@ -1,4 +1,8 @@
 import { isRaw, Utils, } from '@mikro-orm/core';
+/** Flattens `;\n` boundaries so the schema-generator's statement splitter doesn't break the routine DDL apart. Other whitespace is preserved. */
+export function stripStatementNewlines(body) {
+    return body.replace(/;[\t ]*\r?\n/g, '; ');
+}
 /** Base class for database-specific schema helpers. Provides SQL generation for DDL operations. */
 export class SchemaHelper {
     platform;
@@ -827,6 +831,47 @@ export class SchemaHelper {
         }
         return `drop trigger if exists ${this.quote(trigger.name)}`;
     }
+    /** Default no-op so SQLite/libSQL silent-skip routine DDL; routine-capable dialects override. */
+    createRoutine(_routine) {
+        return '';
+    }
+    dropRoutine(_routine) {
+        return '';
+    }
+    async getAllRoutines(_connection, _schemas = []) {
+        return [];
+    }
+    /** Wraps the body in `BEGIN ... END` if not already, and flattens internal `;\n` so the schema-generator's statement splitter doesn't tear the DDL. */
+    wrapRoutineBody(body) {
+        const trimmed = stripStatementNewlines(body).trim();
+        if (/^begin\b/i.test(trimmed)) {
+            return trimmed;
+        }
+        const withSemi = /;\s*$/.test(trimmed) ? trimmed : `${trimmed};`;
+        return `begin ${withSemi} end`;
+    }
+    stripRoutineBody(body) {
+        const match = /^\s*begin\s+([\s\S]*?)\s*end\s*;?\s*$/i.exec(body.trim());
+        if (match) {
+            return match[1].trim().replace(/;\s*$/, '');
+        }
+        return body.trim();
+    }
+    /** T-SQL requires `@name` inside the body; PG/MySQL/Oracle use the bare name. */
+    routineParamReference(name) {
+        return name;
+    }
+    /** T-SQL doesn't distinguish `OUT` from `INOUT` in the catalog — overrides fold `'out'` into `'inout'`. */
+    normaliseRoutineParamDirection(direction) {
+        return direction;
+    }
+    qualifiedRoutineName(routine) {
+        const defaultSchema = this.platform.getDefaultSchemaName();
+        if (routine.schema && routine.schema !== defaultSchema) {
+            return `${this.platform.quoteIdentifier(routine.schema)}.${this.platform.quoteIdentifier(routine.name)}`;
+        }
+        return this.platform.quoteIdentifier(routine.name);
+    }
     /** @internal */
     getTableName(table, schema) {
         if (schema && schema !== this.platform.getDefaultSchemaName()) {

package/schema/SqlSchemaGenerator.js

@@ -47,7 +47,12 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
     getTargetSchema(schema, includeWildcardSchema = false) {
         const metadata = this.getOrderedMetadata(schema, includeWildcardSchema);
         const schemaName = schema ?? this.config.get('schema') ?? this.platform.getDefaultSchemaName();
-        return DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName, this.em);
+        const target = DatabaseSchema.fromMetadata(metadata, this.platform, this.config, schemaName, this.em);
+        const routines = this.config.getRoutines();
+        if (routines.length > 0) {
+            target.addRoutinesFromMetadata(routines, this.platform, this.em);
+        }
+        return target;
     }
     getOrderedMetadata(schema, includeWildcardSchema = false) {
         const metadata = super.getOrderedMetadata(schema, includeWildcardSchema);
@@ -93,6 +98,10 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         for (const view of sortedViews) {
             this.appendViewCreation(ret, view);
         }
+        for (const routine of toSchema.getRoutines()) {
+            // pad=true so each routine is its own batch — MSSQL requires CREATE PROC to be first in a batch.
+            this.append(ret, this.helper.createRoutine(routine), true);
+        }
         return this.wrapSchema(ret, options);
     }
     async drop(options = {}) {
@@ -161,6 +170,10 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
                 this.append(ret, this.helper.dropViewIfExists(view.name, view.schema));
             }
         }
+        // Drop routines before tables - most stored routines reference table columns.
+        for (const routine of targetSchema.getRoutines()) {
+            this.append(ret, this.helper.dropRoutine(routine), true);
+        }
         // remove FKs explicitly if we can't use a cascading statement and we don't disable FK checks (we need this for circular relations)
         for (const meta of metadata) {
             if (!this.platform.usesCascadeStatement() && (!this.options.disableForeignKeys || options.dropForeignKeys)) {
@@ -229,6 +242,11 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         const schemas = toSchema.getNamespaces();
         const fromSchema = options.fromSchema ??
             (await DatabaseSchema.create(this.connection, this.platform, this.config, options.schema, schemas, undefined, this.options.skipTables, this.options.skipViews));
+        // Always load DB routines so orphans are detected when the user removes the last metadata
+        // routine. Dialects without routine support return []; that's the silent-skip path.
+        if (options.fromSchema == null) {
+            await fromSchema.loadRoutines(this.connection, this.platform, [...schemas]);
+        }
         const wildcardSchemaTables = options.includeWildcardSchema
             ? []
             : [...this.metadata.getAll().values()].filter(meta => meta.schema === '*').map(meta => meta.tableName);
@@ -347,6 +365,18 @@ export class SqlSchemaGenerator extends AbstractSchemaGenerator {
         for (const view of sortedChangedViews) {
             this.appendViewCreation(ret, view);
         }
+        if (options.dropTables && !options.safe) {
+            for (const routine of Object.values(schemaDiff.removedRoutines)) {
+                this.append(ret, this.helper.dropRoutine(routine), true);
+            }
+        }
+        for (const change of Object.values(schemaDiff.changedRoutines)) {
+            this.append(ret, this.helper.dropRoutine(change.from), true);
+            this.append(ret, this.helper.createRoutine(change.to), true);
+        }
+        for (const routine of Object.values(schemaDiff.newRoutines)) {
+            this.append(ret, this.helper.createRoutine(routine), true);
+        }
         return this.wrapSchema(ret, options);
     }
     /**

package/typings.d.ts

@@ -1,5 +1,5 @@
 import type { Generated, Kysely } from 'kysely';
-import type { CheckCallback, DeferMode, Dictionary, EntityName, EntityProperty, EntitySchemaWithMeta, FilterQuery, GroupOperator, IndexColumnOptions, InferEntityName, Opt, Primary, PrimaryProperty, QueryFlag, QueryOrderMap, RawQueryFragment, Scalar, Type } from '@mikro-orm/core';
+import type { CheckCallback, DeferMode, Dictionary, EntityName, EntityProperty, EntitySchemaWithMeta, FilterQuery, GroupOperator, IndexColumnOptions, InferEntityName, Opt, Primary, PrimaryProperty, QueryFlag, QueryOrderMap, RawQueryFragment, RoutineIgnoreField, Scalar, Type } from '@mikro-orm/core';
 import type { JoinType, QueryType } from './query/enums.js';
 import type { DatabaseSchema } from './schema/DatabaseSchema.js';
 import type { DatabaseTable } from './schema/DatabaseTable.js';
@@ -124,6 +124,35 @@ export interface SqlTriggerDef {
     when?: string;
     expression?: string;
 }
+/** Resolved routine definition for schema operations (callback bodies resolved to strings). */
+export interface SqlRoutineDef {
+    name: string;
+    schema?: string;
+    type: 'procedure' | 'function';
+    language?: string;
+    comment?: string;
+    security?: 'invoker' | 'definer';
+    definer?: string;
+    deterministic?: boolean;
+    dataAccess?: 'contains-sql' | 'no-sql' | 'reads-sql-data' | 'modifies-sql-data';
+    body?: string;
+    expression?: string;
+    returns?: {
+        type: string;
+        runtimeType?: string;
+        nullable?: boolean;
+    };
+    params: SqlRoutineParamDef[];
+    ignoreSchemaChanges?: RoutineIgnoreField[];
+}
+/** Resolved parameter of a stored routine for schema operations. */
+export interface SqlRoutineParamDef {
+    name: string;
+    type: string;
+    direction: 'in' | 'out' | 'inout';
+    nullable?: boolean;
+    defaultRaw?: string;
+}
 export interface TablePartition {
     name: string;
     schema?: string;
@@ -193,6 +222,12 @@ export interface SchemaDifference {
         to: DatabaseView;
     }>;
     removedViews: Dictionary<DatabaseView>;
+    newRoutines: Dictionary<SqlRoutineDef>;
+    changedRoutines: Dictionary<{
+        from: SqlRoutineDef;
+        to: SqlRoutineDef;
+    }>;
+    removedRoutines: Dictionary<SqlRoutineDef>;
     removedNamespaces: Set<string>;
     removedNativeEnums: {
         name: string;