@mikro-orm/entity-generator 7.1.0-dev.8 → 7.1.0

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/README.md

@@ -2,7 +2,7 @@
   <a href="https://mikro-orm.io"><img src="https://raw.githubusercontent.com/mikro-orm/mikro-orm/master/docs/static/img/logo-readme.svg?sanitize=true" alt="MikroORM" /></a>
 </h1>
 
-TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL, SQLite (including libSQL), MSSQL and Oracle databases.
+TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-orm.io/docs/unit-of-work/) and [Identity Map](https://mikro-orm.io/docs/identity-map/) patterns. Supports MongoDB, MySQL, MariaDB, PostgreSQL (including CockroachDB and PGlite), SQLite (including libSQL), MSSQL and Oracle databases.
 
 > Heavily inspired by [Doctrine](https://www.doctrine-project.org/) and [Hibernate](https://hibernate.org/).
 
@@ -19,6 +19,7 @@ Install a driver package for your database:
 
 ```sh
 npm install @mikro-orm/postgresql   # PostgreSQL
+npm install @mikro-orm/pglite       # PGlite (embedded PostgreSQL in WASM)
 npm install @mikro-orm/mysql        # MySQL
 npm install @mikro-orm/mariadb      # MariaDB
 npm install @mikro-orm/sqlite       # SQLite

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/SourceFile.d.ts

@@ -1,4 +1,4 @@
-import { type Dictionary, type EmbeddableOptions, type EntityMetadata, type EntityOptions, type EntityProperty, type GenerateOptions, type IndexOptions, type NamingStrategy, type OneToOneOptions, type Platform, type UniqueOptions } from '@mikro-orm/core';
+import { type Dictionary, type EmbeddableOptions, type EntityMetadata, type EntityOptions, type EntityPartitionBy, type EntityProperty, type GenerateOptions, type IndexOptions, type NamingStrategy, type OneToOneOptions, type Platform, type UniqueOptions } from '@mikro-orm/core';
 /**
  * @see https://github.com/tc39/proposal-regexp-unicode-property-escapes#other-examples
  */
@@ -30,6 +30,8 @@ export declare class SourceFile {
     protected serializeObject(options: {}, wordwrap?: number, spaces?: number, level?: number): string;
     protected serializeValue(val: unknown, wordwrap?: number, spaces?: number, level?: number): unknown;
     protected getEntityDeclOptions(): EntityOptions<unknown>;
+    private isDiscriminatorPropertyUserDefined;
+    protected getPartitionByDecl(partitionBy: EntityPartitionBy): Dictionary;
     protected getEmbeddableDeclOptions(): EmbeddableOptions<unknown>;
     private getCollectionDecl;
     private getPropertyDecorator;

package/SourceFile.js

@@ -130,6 +130,9 @@ export class SourceFile {
         else if (typeof index.expression === 'function') {
             indexOpt.expression = `${index.expression}`.replace(')=>`', ') => `');
         }
+        if (typeof index.where === 'string') {
+            indexOpt.where = this.quote(index.where);
+        }
         if (isAtEntityLevel && index.properties) {
             indexOpt.properties = Utils.asArray(index.properties).map(prop => this.quote('' + prop));
         }
@@ -170,6 +173,9 @@ export class SourceFile {
         else if (typeof index.expression === 'function') {
             uniqueOpt.expression = `${index.expression}`.replace(')=>`', ') => `');
         }
+        if (typeof index.where === 'string') {
+            uniqueOpt.where = this.quote(index.where);
+        }
         if (isAtEntityLevel && index.properties) {
             uniqueOpt.properties = Utils.asArray(index.properties).map(prop => this.quote('' + prop));
         }
@@ -397,8 +403,11 @@ export class SourceFile {
         const enumTypeName = this.namingStrategy.getEnumTypeName(prop.fieldNames[0], this.meta.collection, this.meta.schema);
         const padding = ' '.repeat(padLeft);
         const enumValues = prop.items;
+        // numeric enums arrive as strings; emit raw numbers so the generated TS reads `Foo: 1` not `Foo: '1'`
+        const allNumeric = enumValues.length > 0 && enumValues.every(item => /^-?\d+$/.test(item));
+        const formatValue = (item) => (allNumeric ? item : this.quote(item));
         if (enumMode === 'union-type') {
-            return `export type ${enumTypeName} = ${enumValues.map(item => this.quote(item)).join(' | ')};\n`;
+            return `export type ${enumTypeName} = ${enumValues.map(formatValue).join(' | ')};\n`;
         }
         let ret = '';
         if (enumMode === 'dictionary') {
@@ -410,10 +419,10 @@ export class SourceFile {
         for (const enumValue of enumValues) {
             const enumName = this.namingStrategy.enumValueToEnumProperty(enumValue, prop.fieldNames[0], this.meta.collection, this.meta.schema);
             if (enumMode === 'dictionary') {
-                ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quote(enumName)}: ${this.quote(enumValue)},\n`;
+                ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quote(enumName)}: ${formatValue(enumValue)},\n`;
             }
             else {
-                ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quote(enumName)} = ${this.quote(enumValue)},\n`;
+                ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quote(enumName)} = ${formatValue(enumValue)},\n`;
             }
         }
         if (enumMode === 'dictionary') {
@@ -475,24 +484,64 @@ export class SourceFile {
         if (this.meta.comment) {
             options.comment = this.quote(this.meta.comment);
         }
+        if (this.meta.partitionBy) {
+            options.partitionBy = this.getPartitionByDecl(this.meta.partitionBy);
+        }
         if (this.meta.readonly && !this.meta.virtual) {
             options.readonly = this.meta.readonly;
         }
         if (this.meta.virtual) {
             options.virtual = this.meta.virtual;
         }
-        return this.getCollectionDecl(options);
+        // when the discriminator references an explicitly defined property, emit the property-oriented
+        // `discriminator` name; fall back to `discriminatorColumn` when the discriminator property is
+        // auto-managed by the ORM and not part of the entity definition.
+        const key = this.isDiscriminatorPropertyUserDefined() ? 'discriminator' : 'discriminatorColumn';
+        return this.getCollectionDecl(options, key);
     }
-    getEmbeddableDeclOptions() {
-        const options = {};
-        const result = this.getCollectionDecl(options);
-        if (result.discriminatorColumn) {
-            result.discriminator = result.discriminatorColumn;
-            delete result.discriminatorColumn;
+    isDiscriminatorPropertyUserDefined() {
+        const name = this.meta.discriminatorColumn;
+        return !!name && this.meta.properties[name]?.userDefined !== false;
+    }
+    getPartitionByDecl(partitionBy) {
+        const result = { type: this.quote(partitionBy.type) };
+        // Introspected metadata from `toEntityPartitionBy` always emits a string or string[];
+        // callback-form expressions only exist in hand-written entity metadata. Fail loud if a
+        // callback ever reaches the generator — stringifying `fn.toString()` would produce source
+        // that re-imports nothing and will not compile.
+        if (typeof partitionBy.expression === 'function') {
+            throw new Error(`Cannot emit entity source for ${this.meta.className}: partitionBy.expression is a callback. ` +
+                `Entity generator expects string or string[] expressions from catalog introspection.`);
+        }
+        const expression = partitionBy.expression;
+        if (Array.isArray(expression)) {
+            result.expression = expression.map(key => this.quote(String(key)));
+        }
+        else {
+            result.expression = this.quote(String(expression));
+        }
+        if (partitionBy.type === 'hash') {
+            result.partitions = Array.isArray(partitionBy.partitions)
+                ? partitionBy.partitions.map(name => this.quote(String(name)))
+                : partitionBy.partitions;
+        }
+        else {
+            result.partitions = partitionBy.partitions.map(partition => {
+                const entry = {};
+                if (partition.name) {
+                    entry.name = this.quote(partition.name);
+                }
+                entry.values = this.quote(partition.values);
+                return entry;
+            });
         }
         return result;
     }
-    getCollectionDecl(options) {
+    getEmbeddableDeclOptions() {
+        const options = {};
+        return this.getCollectionDecl(options, 'discriminator');
+    }
+    getCollectionDecl(options, discriminatorKey) {
         if (this.meta.abstract) {
             options.abstract = true;
         }
@@ -503,7 +552,7 @@ export class SourceFile {
                     : this.meta.discriminatorValue;
         }
         if (this.meta.discriminatorColumn) {
-            options.discriminatorColumn = this.quote(this.meta.discriminatorColumn);
+            options[discriminatorKey] = this.quote(this.meta.discriminatorColumn);
         }
         if (this.meta.discriminatorMap) {
             options.discriminatorMap = Object.fromEntries(Object.entries(this.meta.discriminatorMap).map(([discriminatorValue, cls]) => [
@@ -615,6 +664,9 @@ export class SourceFile {
         if (typeof prop.comment === 'string') {
             options.comment = this.quote(prop.comment);
         }
+        if (typeof prop.collation === 'string') {
+            options.collation = this.quote(prop.collation);
+        }
         // TODO: Composite FKs with default values require additions to default/defaultRaw that are not yet supported.
         if (prop.fieldNames?.length <= 1) {
             if (typeof prop.defaultRaw !== 'undefined' &&
@@ -708,7 +760,9 @@ export class SourceFile {
         }
         if (prop.enum) {
             if (this.options.enumMode === 'union-type') {
-                options.items = `[${prop.items.map(item => this.quote(item)).join(', ')}]`;
+                const items = prop.items;
+                const allNumeric = items.length > 0 && items.every(item => /^-?\d+$/.test(item));
+                options.items = `[${items.map(item => (allNumeric ? item : this.quote(item))).join(', ')}]`;
             }
             else if (prop.nativeEnumName) {
                 const enumClassName = this.namingStrategy.getEnumClassName(prop.nativeEnumName, undefined, this.meta.schema);

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.8",
+  "version": "7.1.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",
@@ -47,13 +47,13 @@
     "copy": "node ../../scripts/copy.mjs"
   },
   "dependencies": {
-    "@mikro-orm/sql": "7.1.0-dev.8"
+    "@mikro-orm/sql": "7.1.0"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.0.11"
+    "@mikro-orm/core": "^7.1.0"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.1.0-dev.8"
+    "@mikro-orm/core": "7.1.0"
   },
   "engines": {
     "node": ">= 22.17.0"