@mikro-orm/entity-generator 7.2.0-dev.2 → 7.2.0-dev.21

package/DefineEntitySourceFile.js

@@ -38,6 +38,9 @@ export class DefineEntitySourceFile extends EntitySchemaSourceFile {
         if (this.meta.uniques.length > 0) {
             entitySchemaOptions.uniques = this.meta.uniques.map(index => this.getUniqueOptions(index));
         }
+        if (this.meta.checks.length > 0) {
+            entitySchemaOptions.checks = this.meta.checks.map(check => this.getCheckOptions(check));
+        }
         entitySchemaOptions.properties = Object.fromEntries(Object.entries(this.meta.properties).map(([name, prop]) => [name, this.getPropertyBuilder(prop)]));
         // Force top level and properties to be indented, regardless of line length
         entitySchemaOptions[Config] = true;

package/EntityGenerator.d.ts

@@ -7,6 +7,8 @@ export declare class EntityGenerator {
     static register(orm: MikroORM): void;
     generate(options?: GenerateOptions): Promise<string[]>;
     private getEntityMetadata;
+    /** Carries introspected RLS state (policies + enablement) from the table onto the entity metadata. */
+    private applyRowLevelSecurity;
     private cleanUpReferentialIntegrityRules;
     private matchName;
     private detectManyToManyRelations;

package/EntityGenerator.js

@@ -1,7 +1,7 @@
 import { EntitySchema, ReferenceKind, types, Utils, } from '@mikro-orm/core';
 import { DatabaseSchema, } from '@mikro-orm/sql';
 import { fs } from '@mikro-orm/core/fs-utils';
-import { dirname, join } from 'node:path';
+import { dirname, join, relative, resolve } from 'node:path';
 import { writeFile } from 'node:fs/promises';
 import { DefineEntitySourceFile } from './DefineEntitySourceFile.js';
 import { EntitySchemaSourceFile } from './EntitySchemaSourceFile.js';
@@ -62,6 +62,15 @@ export class EntityGenerator {
         }
         const files = this.#sources.map(file => [file.getBaseName(), file.generate()]);
         if (options.save) {
+            // generated files may only land in the project folder, or under the configured path when
+            // that points elsewhere, so a file name can never reach an arbitrary filesystem location
+            const allowedRoots = [resolve(this.#config.get('baseDir')), resolve(baseDir)];
+            for (const [fileName] of files) {
+                const target = resolve(baseDir, fileName);
+                if (!allowedRoots.some(root => !relative(root, target).startsWith('..'))) {
+                    throw new Error(`Cannot generate '${fileName}', it resolves outside of the project folder`);
+                }
+            }
             fs.ensureDir(baseDir);
             const promises = [];
             for (const [fileName, data] of files) {
@@ -91,7 +100,9 @@ export class EntityGenerator {
                     }
                 }
             }
-            return table.getEntityDeclaration(this.#namingStrategy, this.#helper, options.scalarPropertiesForRelations);
+            const meta = table.getEntityDeclaration(this.#namingStrategy, this.#helper, options.scalarPropertiesForRelations);
+            this.applyRowLevelSecurity(meta, table);
+            return meta;
         });
         for (const meta of metadata) {
             for (const prop of meta.relations) {
@@ -150,6 +161,28 @@ export class EntityGenerator {
         await options.onProcessedMetadata?.(metadata, this.#platform);
         return metadata;
     }
+    /** Carries introspected RLS state (policies + enablement) from the table onto the entity metadata. */
+    applyRowLevelSecurity(meta, table) {
+        meta.policies = table.getPolicies().map(policy => ({
+            name: policy.name,
+            command: policy.command,
+            type: policy.type,
+            roles: policy.roles,
+            ...(policy.using != null ? { using: policy.using } : {}),
+            ...(policy.check != null ? { check: policy.check } : {}),
+        }));
+        if (table.rlsForced) {
+            meta.rowLevelSecurity = 'force';
+        }
+        else if (table.rlsEnabled) {
+            meta.rowLevelSecurity = true;
+        }
+        else if (meta.policies.length > 0) {
+            // policies staged but RLS disabled — record it explicitly so a reload does not re-enable RLS via the
+            // policies-imply-RLS default
+            meta.rowLevelSecurity = false;
+        }
+    }
     cleanUpReferentialIntegrityRules(metadata) {
         // Clear FK rules that match defaults for:
         // 1. FK-as-PK entities (all PKs are FKs) - cascade for both update and delete

package/EntitySchemaSourceFile.js

@@ -33,6 +33,9 @@ export class EntitySchemaSourceFile extends SourceFile {
         if (this.meta.uniques.length > 0) {
             entitySchemaOptions.uniques = this.meta.uniques.map(index => this.getUniqueOptions(index));
         }
+        if (this.meta.checks.length > 0) {
+            entitySchemaOptions.checks = this.meta.checks.map(check => this.getCheckOptions(check));
+        }
         entitySchemaOptions.properties = Object.fromEntries(Object.entries(this.meta.properties).map(([name, prop]) => [name, this.getPropertyOptions(prop)]));
         // Force top level and properties to be indented, regardless of line length
         entitySchemaOptions[Config] = true;
@@ -64,7 +67,7 @@ export class EntitySchemaSourceFile extends SourceFile {
             }
         }
         if (primaryProps.length > 0) {
-            const primaryPropNames = primaryProps.map(prop => `'${prop.name}'`);
+            const primaryPropNames = primaryProps.map(prop => this.quoteKey(prop.name));
             if (primaryProps.length > 1) {
                 classBody += `${' '.repeat(2)}[${this.referenceCoreImport('PrimaryKeyProp')}]?: [${primaryPropNames.join(', ')}];\n`;
             }
@@ -73,7 +76,7 @@ export class EntitySchemaSourceFile extends SourceFile {
             }
         }
         if (eagerProperties.length > 0) {
-            const eagerPropertyNames = eagerProperties.map(prop => `'${prop.name}'`).sort();
+            const eagerPropertyNames = eagerProperties.map(prop => this.quoteKey(prop.name)).sort();
             classBody += `${' '.repeat(2)}[${this.referenceCoreImport('EagerProps')}]?: ${eagerPropertyNames.join(' | ')};\n`;
         }
         classBody += props.join('');

package/NativeEnumSourceFile.js

@@ -24,10 +24,10 @@ export class NativeEnumSourceFile extends SourceFile {
         for (const enumValue of enumValues) {
             const enumName = this.namingStrategy.enumValueToEnumProperty(enumValue, this.nativeEnum.name, '', this.nativeEnum.schema);
             if (enumMode === 'dictionary') {
-                ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quote(enumName)}: ${this.quote(enumValue)},\n`;
+                ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quoteKey(enumName)}: ${this.quote(enumValue)},\n`;
             }
             else {
-                ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quote(enumName)} = ${this.quote(enumValue)},\n`;
+                ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quoteKey(enumName)} = ${this.quote(enumValue)},\n`;
             }
         }
         if (enumMode === 'dictionary') {
@@ -42,6 +42,9 @@ export class NativeEnumSourceFile extends SourceFile {
         return ret;
     }
     getBaseName(extension = '.ts') {
-        return `${this.options.fileName(this.nativeEnum.name)}${extension}`;
+        // the enum name comes from the database and ends up in a path, so path separators
+        // (and anything else that cannot appear in a file name) collapse to `_`
+        const name = this.nativeEnum.name.replaceAll(/[^\p{L}\p{N}$_-]+/gu, '_');
+        return `${this.options.fileName(name)}${extension}`;
     }
 }

package/RoutineSourceFile.js

@@ -20,7 +20,9 @@ function quoteMultiline(val) {
 }
 function toPascalCase(name) {
     const pascal = name
-        .split(/[_\s-]+/)
+        // anything that cannot appear in an identifier acts as a word separator, which keeps
+        // path separators out of both the emitted const name and the generated file name
+        .split(/[^\p{L}\p{N}$]+/u)
         .filter(Boolean)
         .map(part => part.charAt(0).toUpperCase() + part.slice(1))
         .join('');

package/SourceFile.d.ts

@@ -1,4 +1,4 @@
-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';
+import { type CheckConstraint, 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
  */
@@ -21,10 +21,13 @@ export declare class SourceFile {
     private getColumnOptions;
     protected getIndexOptions(index: EntityMetadata['indexes'][number], isAtEntityLevel?: boolean): IndexOptions<Dictionary, string>;
     protected getUniqueOptions(index: EntityMetadata['uniques'][number], isAtEntityLevel?: boolean): UniqueOptions<Dictionary, string>;
+    protected getCheckOptions(check: EntityMetadata['checks'][number]): CheckConstraint<Dictionary>;
     protected generateImports(): string;
     protected getEntityClass(classBody: string): string;
     getBaseName(extension?: string): string;
     protected quote(val: string): string;
+    /** For positions that reject a template literal: object keys, import bindings/specifiers, string literal types. */
+    protected quoteKey(val: string): string;
     protected getPropertyDefinition(prop: EntityProperty, padLeft: number): string;
     protected getEnumClassDefinition(prop: EntityProperty, padLeft: number): string;
     protected serializeObject(options: {}, wordwrap?: number, spaces?: number, level?: number): string;
@@ -32,6 +35,7 @@ export declare class SourceFile {
     protected getEntityDeclOptions(): EntityOptions<unknown>;
     private isDiscriminatorPropertyUserDefined;
     protected getPartitionByDecl(partitionBy: EntityPartitionBy): Dictionary;
+    protected getPolicyDecl(policy: EntityMetadata['policies'][number]): Dictionary;
     protected getEmbeddableDeclOptions(): EmbeddableOptions<unknown>;
     private getCollectionDecl;
     private getPropertyDecorator;

package/SourceFile.js

@@ -1,4 +1,5 @@
 import { Cascade, Config, DecimalType, ReferenceKind, SCALAR_TYPES, UnknownType, Utils, inspect, } from '@mikro-orm/core';
+import { DatabaseTable } from '@mikro-orm/sql';
 import { parse, relative } from 'node:path';
 import { POSSIBLE_TYPE_IMPORTS } from './CoreImportsHelper.js';
 /**
@@ -26,11 +27,13 @@ export class SourceFile {
         if (this.meta.embeddable || this.meta.collection) {
             if (this.meta.embeddable) {
                 const options = this.getEmbeddableDeclOptions();
-                ret += `@${this.referenceDecoratorImport('Embeddable')}(${Utils.hasObjectKeys(options) ? this.serializeObject(options) : ''})\n`;
+                const decl = `@${this.referenceDecoratorImport('Embeddable')}(`;
+                ret += `${decl}${Utils.hasObjectKeys(options) ? this.serializeObject(options, 80 - decl.length, 0) : ''})\n`;
             }
             else {
                 const options = this.getEntityDeclOptions();
-                ret += `@${this.referenceDecoratorImport('Entity')}(${Utils.hasObjectKeys(options) ? this.serializeObject(options) : ''})\n`;
+                const decl = `@${this.referenceDecoratorImport('Entity')}(`;
+                ret += `${decl}${Utils.hasObjectKeys(options) ? this.serializeObject(options, 80 - decl.length, 0) : ''})\n`;
             }
         }
         for (const index of this.meta.indexes) {
@@ -45,6 +48,9 @@ export class SourceFile {
             }
             ret += `@${this.referenceDecoratorImport('Unique')}(${this.serializeObject(this.getUniqueOptions(index))})\n`;
         }
+        for (const check of this.meta.checks) {
+            ret += `@${this.referenceDecoratorImport('Check')}(${this.serializeObject(this.getCheckOptions(check))})\n`;
+        }
         let classHead = '';
         if (this.meta.className === this.options.customBaseEntityName) {
             const defineConfigTypeSettings = {};
@@ -79,7 +85,7 @@ export class SourceFile {
             }
         });
         if (primaryProps.length > 0) {
-            const primaryPropNames = primaryProps.map(prop => `'${prop.name}'`);
+            const primaryPropNames = primaryProps.map(prop => this.quoteKey(prop.name));
             if (primaryProps.length > 1) {
                 classHead += `\n${' '.repeat(2)}[${this.referenceCoreImport('PrimaryKeyProp')}]?: [${primaryPropNames.join(', ')}];\n`;
             }
@@ -88,7 +94,7 @@ export class SourceFile {
             }
         }
         if (eagerProperties.length > 0) {
-            const eagerPropertyNames = eagerProperties.map(prop => `'${prop.name}'`).sort();
+            const eagerPropertyNames = eagerProperties.map(prop => this.quoteKey(prop.name)).sort();
             classHead += `\n${' '.repeat(2)}[${this.referenceCoreImport('EagerProps')}]?: ${eagerPropertyNames.join(' | ')};\n`;
         }
         ret += this.getEntityClass(classBody ? `${classHead}\n${classBody}` : classHead);
@@ -198,6 +204,14 @@ export class SourceFile {
         }
         return uniqueOpt;
     }
+    getCheckOptions(check) {
+        const checkOpt = {};
+        if (typeof check.name === 'string') {
+            checkOpt.name = this.quote(check.name);
+        }
+        checkOpt.expression = this.quote(check.expression);
+        return checkOpt;
+    }
     generateImports() {
         const imports = new Set();
         if (this.coreImports.size > 0) {
@@ -242,22 +256,22 @@ export class SourceFile {
                 if (file.name === '') {
                     continue;
                 }
-                importMap.set(file.path, `import ${this.quote(file.name)};`);
+                importMap.set(file.path, `import ${this.quoteKey(file.name)};`);
                 continue;
             }
             if (file.name === '') {
-                importMap.set(file.path, `import * as ${entity} from ${this.quote(file.path)};`);
+                importMap.set(file.path, `import * as ${entity} from ${this.quoteKey(file.path)};`);
                 continue;
             }
             if (file.name === 'default') {
-                importMap.set(file.path, `import ${entity} from ${this.quote(file.path)};`);
+                importMap.set(file.path, `import ${entity} from ${this.quoteKey(file.path)};`);
                 continue;
             }
             if (file.name === entity) {
-                importMap.set(file.path, `import { ${entity} } from ${this.quote(file.path)};`);
+                importMap.set(file.path, `import { ${entity} } from ${this.quoteKey(file.path)};`);
                 continue;
             }
-            importMap.set(file.path, `import { ${identifierRegex.test(file.name) ? file.name : this.quote(file.name)} as ${entity} } from ${this.quote(file.path)};`);
+            importMap.set(file.path, `import { ${identifierRegex.test(file.name) ? file.name : this.quoteKey(file.name)} as ${entity} } from ${this.quoteKey(file.path)};`);
         }
         if (this.enumImports.size) {
             for (const [name, exports] of this.enumImports.entries()) {
@@ -265,7 +279,7 @@ export class SourceFile {
                     path: `${basePath}/${this.options.fileName(name)}${extension}`,
                     name,
                 };
-                importMap.set(file.path, `import { ${exports.join(', ')} } from ${this.quote(file.path)};`);
+                importMap.set(file.path, `import { ${exports.join(', ')} } from ${this.quoteKey(file.path)};`);
             }
         }
         for (const key of [...importMap.keys()].sort()) {
@@ -294,12 +308,26 @@ export class SourceFile {
     }
     quote(val) {
         const backtick = val.startsWith(`'`) || val.includes('\n');
-        /* v8 ignore next */
-        return backtick ? `\`${val.replaceAll('`', '\\``')}\`` : `'${val.replaceAll(`'`, `\\'`)}'`;
+        // Backslashes first, so the escapes added below don't get neutralized by a preceding `\`.
+        // A raw `\r` is a syntax error in a string literal and silently normalizes to `\n` in a template one.
+        const escaped = val.replaceAll('\\', '\\\\').replaceAll('\r', '\\r');
+        return backtick
+            ? `\`${escaped.replaceAll('`', '\\`').replaceAll('${', '\\${')}\``
+            : `'${escaped.replaceAll(`'`, `\\'`)}'`;
+    }
+    /** For positions that reject a template literal: object keys, import bindings/specifiers, string literal types. */
+    quoteKey(val) {
+        const escaped = val
+            .replaceAll('\\', '\\\\')
+            .replaceAll('\r', '\\r')
+            .replaceAll('\n', '\\n')
+            .replaceAll('\t', '\\t')
+            .replaceAll(`'`, `\\'`);
+        return `'${escaped}'`;
     }
     getPropertyDefinition(prop, padLeft) {
         const padding = ' '.repeat(padLeft);
-        const propName = identifierRegex.test(prop.name) ? prop.name : this.quote(prop.name);
+        const propName = identifierRegex.test(prop.name) ? prop.name : this.quoteKey(prop.name);
         const enumMode = this.options.enumMode;
         let hiddenType = '';
         if (prop.hidden) {
@@ -419,10 +447,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)}: ${formatValue(enumValue)},\n`;
+                ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quoteKey(enumName)}: ${formatValue(enumValue)},\n`;
             }
             else {
-                ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quote(enumName)} = ${formatValue(enumValue)},\n`;
+                ret += `${padding}${identifierRegex.test(enumName) ? enumName : this.quoteKey(enumName)} = ${formatValue(enumValue)},\n`;
             }
         }
         if (enumMode === 'dictionary') {
@@ -452,7 +480,7 @@ export class SourceFile {
         const entries = Object.entries(options);
         return `{${doIndent ? `\n${' '.repeat(spaces)}` : ' '}${entries
             .map(([opt, val]) => {
-            const key = identifierRegex.test(opt) ? opt : this.quote(opt);
+            const key = identifierRegex.test(opt) ? opt : this.quoteKey(opt);
             return `${doIndent ? ' '.repeat(level * 2 + (spaces + 2)) : ''}${key}: ${this.serializeValue(val, typeof nextWordwrap === 'number' ? nextWordwrap - key.length - 2 /* ': '.length*/ : undefined, doIndent ? spaces : undefined, level + 1)}`;
         })
             .join(sep)}${doIndent ? `${entries.length > 0 ? ',\n' : ''}${' '.repeat(spaces + level * 2)}` : ' '}}`;
@@ -487,6 +515,21 @@ export class SourceFile {
         if (this.meta.partitionBy) {
             options.partitionBy = this.getPartitionByDecl(this.meta.partitionBy);
         }
+        // policies imply RLS on reload, so only emit `rowLevelSecurity` when it adds information:
+        // `'force'` always, plain `true` only for a deny-all table (enabled with no policies),
+        // and explicit `false` only when policies are staged but RLS is disabled
+        if (this.meta.rowLevelSecurity === 'force') {
+            options.rowLevelSecurity = this.quote('force');
+        }
+        else if (this.meta.rowLevelSecurity === true && this.meta.policies.length === 0) {
+            options.rowLevelSecurity = true;
+        }
+        else if (this.meta.rowLevelSecurity === false && this.meta.policies.length > 0) {
+            options.rowLevelSecurity = false;
+        }
+        if (this.meta.policies.length > 0) {
+            options.policies = this.meta.policies.map(policy => this.getPolicyDecl(policy));
+        }
         if (this.meta.readonly && !this.meta.virtual) {
             options.readonly = this.meta.readonly;
         }
@@ -537,6 +580,27 @@ export class SourceFile {
         }
         return result;
     }
+    getPolicyDecl(policy) {
+        // introspected names are always explicit; the rest is emitted only when it differs from the default
+        const result = { name: this.quote(policy.name) };
+        if (policy.command && policy.command !== 'all') {
+            result.command = this.quote(policy.command);
+        }
+        if (policy.type && policy.type !== 'permissive') {
+            result.type = this.quote(policy.type);
+        }
+        const roles = policy.roles;
+        if (roles && !DatabaseTable.isDefaultPolicyRoles(roles)) {
+            result.roles = roles.map(role => this.quote(role));
+        }
+        if (typeof policy.using === 'string') {
+            result.using = this.quote(policy.using);
+        }
+        if (typeof policy.check === 'string') {
+            result.check = this.quote(policy.check);
+        }
+        return result;
+    }
     getEmbeddableDeclOptions() {
         const options = {};
         return this.getCollectionDecl(options, 'discriminator');
@@ -673,7 +737,8 @@ export class SourceFile {
                 prop.defaultRaw !== 'null' &&
                 prop.defaultRaw !== '' &&
                 prop.defaultRaw !== (typeof prop.default === 'string' ? this.quote(prop.default) : `${prop.default}`)) {
-                options.defaultRaw = `\`${prop.defaultRaw}\``;
+                // kept as a template literal for readability, but raw SQL may contain `${`, which would otherwise interpolate
+                options.defaultRaw = `\`${prop.defaultRaw.replaceAll('\\', '\\\\').replaceAll('`', '\\`').replaceAll('${', '\\${')}\``;
             }
             else if (!(typeof prop.default === 'undefined' || prop.default === null) &&
                 (prop.ref ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/entity-generator",
-  "version": "7.2.0-dev.2",
+  "version": "7.2.0-dev.21",
   "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.2.0-dev.2"
+    "@mikro-orm/sql": "7.2.0-dev.21"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^7.1.7"
+    "@mikro-orm/core": "^7.1.15"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.2.0-dev.2"
+    "@mikro-orm/core": "7.2.0-dev.21"
   },
   "engines": {
     "node": ">= 22.17.0"