@mikro-orm/entity-generator 7.1.0-dev.43 → 7.1.0-dev.44

package/EntityGenerator.js

@@ -6,6 +6,7 @@ import { writeFile } from 'node:fs/promises';
 import { DefineEntitySourceFile } from './DefineEntitySourceFile.js';
 import { EntitySchemaSourceFile } from './EntitySchemaSourceFile.js';
 import { NativeEnumSourceFile } from './NativeEnumSourceFile.js';
+import { RoutineSourceFile } from './RoutineSourceFile.js';
 import { SourceFile } from './SourceFile.js';
 /** Generates entity source files by introspecting an existing database schema. */
 export class EntityGenerator {
@@ -33,6 +34,8 @@ export class EntityGenerator {
     async generate(options = {}) {
         options = Utils.mergeConfig({}, this.#config.get('entityGenerator'), options);
         const schema = await DatabaseSchema.create(this.#connection, this.#platform, this.#config, undefined, undefined, options.takeTables, options.skipTables);
+        // The generator emits whatever it can find, so always load routines here.
+        await schema.loadRoutines(this.#connection, this.#platform);
         const metadata = await this.getEntityMetadata(schema, options);
         const defaultPath = `${this.#config.get('baseDir')}/generated-entities`;
         const baseDir = fs.normalizePath(options.path ?? defaultPath);
@@ -54,6 +57,9 @@ export class EntityGenerator {
         for (const nativeEnum of Object.values(schema.getNativeEnums())) {
             this.#sources.push(new NativeEnumSourceFile({}, this.#namingStrategy, this.#platform, options, nativeEnum));
         }
+        for (const routine of schema.getRoutines()) {
+            this.#sources.push(new RoutineSourceFile(routine, this.#namingStrategy, this.#platform, options));
+        }
         const files = this.#sources.map(file => [file.getBaseName(), file.generate()]);
         if (options.save) {
             fs.ensureDir(baseDir);

package/RoutineSourceFile.d.ts

@@ -0,0 +1,17 @@
+import type { GenerateOptions, NamingStrategy, Platform } from '@mikro-orm/core';
+import type { SqlRoutineDef } from '@mikro-orm/sql';
+/** Always emits the class-less `new Routine(...)` form; there is no decorator form for routines. */
+export declare class RoutineSourceFile {
+    private readonly routine;
+    private readonly namingStrategy;
+    private readonly platform;
+    private readonly options;
+    constructor(routine: SqlRoutineDef, namingStrategy: NamingStrategy, platform: Platform, options: GenerateOptions);
+    generate(): string;
+    getBaseName(extension?: string): string;
+    getClassName(): string;
+    private buildConfig;
+    private formatParams;
+    private formatReturns;
+    private emitRoutine;
+}

package/RoutineSourceFile.js

@@ -0,0 +1,136 @@
+const identifierRegex = /^(?:[$_\p{ID_Start}])(?:[$\p{ID_Continue}])*$/u;
+function quote(val) {
+    // Backslashes first so subsequent escapes don't double up the `\` we just added.
+    const escaped = val
+        .replaceAll('\\', '\\\\')
+        .replaceAll('\r', '\\r')
+        .replaceAll('\n', '\\n')
+        .replaceAll('\t', '\\t')
+        .replaceAll(`'`, `\\'`);
+    return `'${escaped}'`;
+}
+function safeKey(name) {
+    return identifierRegex.test(name) ? name : quote(name);
+}
+function quoteMultiline(val) {
+    if (val.includes('\n') || val.includes('`') || val.includes('${')) {
+        return `\`${val.replaceAll('\\', '\\\\').replaceAll('`', '\\`').replaceAll('${', '\\${')}\``;
+    }
+    return quote(val);
+}
+function toPascalCase(name) {
+    const pascal = name
+        .split(/[_\s-]+/)
+        .filter(Boolean)
+        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+    // A routine name starting with a digit (e.g. `2fa_check`) would yield an invalid identifier;
+    // prefix `_` so the emitted `export const ...` parses.
+    return /^[A-Za-z_$]/.test(pascal) ? pascal : `_${pascal}`;
+}
+// `satisfies` ties this list to `RoutineRuntimeType` so the runtime set can't drift from the union.
+const ROUTINE_RUNTIME_TYPES = [
+    'string',
+    'number',
+    'boolean',
+    'bigint',
+    'Buffer',
+    'Date',
+    'object',
+    'any',
+];
+const ROUTINE_RUNTIME_TYPE_SET = new Set(ROUTINE_RUNTIME_TYPES);
+function narrowRuntimeType(runtimeType) {
+    return runtimeType && ROUTINE_RUNTIME_TYPE_SET.has(runtimeType) ? runtimeType : 'any';
+}
+/** Always emits the class-less `new Routine(...)` form; there is no decorator form for routines. */
+export class RoutineSourceFile {
+    routine;
+    namingStrategy;
+    platform;
+    options;
+    constructor(routine, namingStrategy, platform, options) {
+        this.routine = routine;
+        this.namingStrategy = namingStrategy;
+        this.platform = platform;
+        this.options = options;
+    }
+    generate() {
+        return this.emitRoutine(this.getClassName(), this.buildConfig());
+    }
+    getBaseName(extension = '.ts') {
+        return `${this.options.fileName(this.getClassName())}${extension}`;
+    }
+    getClassName() {
+        return toPascalCase(this.routine.name);
+    }
+    buildConfig() {
+        const lines = [];
+        lines.push(`  name: ${quote(this.routine.name)},`);
+        lines.push(`  type: ${quote(this.routine.type)},`);
+        if (this.routine.schema) {
+            lines.push(`  schema: ${quote(this.routine.schema)},`);
+        }
+        if (this.routine.language) {
+            lines.push(`  language: ${quote(this.routine.language)},`);
+        }
+        if (this.routine.security) {
+            lines.push(`  security: ${quote(this.routine.security)},`);
+        }
+        if (this.routine.deterministic != null) {
+            lines.push(`  deterministic: ${this.routine.deterministic},`);
+        }
+        if (this.routine.comment) {
+            lines.push(`  comment: ${quote(this.routine.comment)},`);
+        }
+        if (this.routine.params.length > 0) {
+            lines.push(`  params: ${this.formatParams(this.routine.params)},`);
+        }
+        else {
+            lines.push(`  params: {},`);
+        }
+        if (this.routine.returns) {
+            lines.push(`  returns: ${this.formatReturns(this.routine.returns)},`);
+        }
+        if (this.routine.body) {
+            lines.push(`  body: ${quoteMultiline(this.routine.body)},`);
+        }
+        else if (this.routine.expression) {
+            lines.push(`  expression: ${quoteMultiline(this.routine.expression)},`);
+        }
+        return `{\n${lines.join('\n')}\n}`;
+    }
+    formatParams(params) {
+        const lines = params.map(p => {
+            const parts = [`type: ${quote(p.type)}`];
+            if (p.direction !== 'in') {
+                parts.push(`direction: ${quote(p.direction)}`);
+            }
+            if (p.direction === 'out' || p.direction === 'inout') {
+                parts.push(`ref: true`);
+            }
+            if (p.nullable) {
+                parts.push(`nullable: true`);
+            }
+            if (p.defaultRaw) {
+                parts.push(`defaultRaw: ${quote(p.defaultRaw)}`);
+            }
+            return `    ${safeKey(p.name)}: { ${parts.join(', ')} },`;
+        });
+        return `{\n${lines.join('\n')}\n  }`;
+    }
+    formatReturns(returns) {
+        const parts = [];
+        // Narrow to `RoutineRuntimeType`; unrecognised types collapse to `'any'`.
+        const inferred = returns.runtimeType ?? this.platform.getMappedType(returns.type)?.runtimeType;
+        parts.push(`runtimeType: ${quote(narrowRuntimeType(inferred))}`);
+        parts.push(`columnType: ${quote(returns.type)}`);
+        if (returns.nullable) {
+            parts.push(`nullable: true`);
+        }
+        return `{ ${parts.join(', ')} }`;
+    }
+    emitRoutine(className, config) {
+        return `import { Routine } from '@mikro-orm/core';\n\nexport const ${className} = new Routine(${config});\n`;
+    }
+}

package/index.d.ts

@@ -3,3 +3,4 @@
  * @module entity-generator
  */
 export * from './EntityGenerator.js';
+export * from './RoutineSourceFile.js';

package/index.js

@@ -3,3 +3,4 @@
  * @module entity-generator
  */
 export * from './EntityGenerator.js';
+export * from './RoutineSourceFile.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/entity-generator",
-  "version": "7.1.0-dev.43",
+  "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",
@@ -47,13 +47,13 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/sql": "7.1.0-dev.43"
+    "@mikro-orm/sql": "7.1.0-dev.44"
   },
   "devDependencies": {
     "@mikro-orm/core": "^7.0.17"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.43"
+    "@mikro-orm/core": "7.1.0-dev.44"
   },
   "engines": {
     "node": ">= 22.17.0"