@yandjin-mikro-orm/entity-generator 6.1.4-rc-sti-changes-1

package/EntityGenerator.d.ts

@@ -0,0 +1,21 @@
+import { type GenerateOptions, type MikroORM } from "@yandjin-mikro-orm/core";
+import { type EntityManager } from "@yandjin-mikro-orm/knex";
+export declare class EntityGenerator {
+    private readonly em;
+    private readonly config;
+    private readonly driver;
+    private readonly platform;
+    private readonly helper;
+    private readonly connection;
+    private readonly namingStrategy;
+    private readonly sources;
+    private readonly referencedEntities;
+    constructor(em: EntityManager);
+    static register(orm: MikroORM): void;
+    generate(options?: GenerateOptions): Promise<string[]>;
+    private getEntityMetadata;
+    private detectManyToManyRelations;
+    private generateBidirectionalRelations;
+    private generateIdentifiedReferences;
+    private generateAndAttachCustomBaseEntity;
+}

package/EntityGenerator.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityGenerator = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const knex_1 = require("@yandjin-mikro-orm/knex");
+const fs_extra_1 = require("fs-extra");
+const EntitySchemaSourceFile_1 = require("./EntitySchemaSourceFile");
+const SourceFile_1 = require("./SourceFile");
+class EntityGenerator {
+    em;
+    config;
+    driver;
+    platform;
+    helper;
+    connection;
+    namingStrategy;
+    sources = [];
+    referencedEntities = new WeakSet();
+    constructor(em) {
+        this.em = em;
+        this.config = this.em.config;
+        this.driver = this.em.getDriver();
+        this.platform = this.driver.getPlatform();
+        this.helper = this.platform.getSchemaHelper();
+        this.connection = this.driver.getConnection();
+        this.namingStrategy = this.config.getNamingStrategy();
+    }
+    static register(orm) {
+        orm.config.registerExtension("@mikro-orm/entity-generator", () => new EntityGenerator(orm.em));
+    }
+    async generate(options = {}) {
+        options = core_1.Utils.mergeConfig({}, this.config.get("entityGenerator"), options);
+        const schema = await knex_1.DatabaseSchema.create(this.connection, this.platform, this.config);
+        const metadata = await this.getEntityMetadata(schema, options);
+        const defaultPath = `${this.config.get("baseDir")}/generated-entities`;
+        const baseDir = core_1.Utils.normalizePath(options.path ?? defaultPath);
+        for (const meta of metadata) {
+            if (!meta.pivotTable || this.referencedEntities.has(meta)) {
+                if (options.entitySchema) {
+                    this.sources.push(new EntitySchemaSourceFile_1.EntitySchemaSourceFile(meta, this.namingStrategy, this.platform, { ...options, scalarTypeInDecorator: true }));
+                }
+                else {
+                    this.sources.push(new SourceFile_1.SourceFile(meta, this.namingStrategy, this.platform, options));
+                }
+            }
+        }
+        if (options.save) {
+            await (0, fs_extra_1.ensureDir)(baseDir);
+            await Promise.all(this.sources.map((file) => (0, fs_extra_1.writeFile)(baseDir + "/" + file.getBaseName(), file.generate(), {
+                flush: true,
+            })));
+        }
+        return this.sources.map((file) => file.generate());
+    }
+    async getEntityMetadata(schema, options) {
+        let metadata = schema
+            .getTables()
+            .filter((table) => !options.schema || table.schema === options.schema)
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map((table) => {
+            const skipColumns = options.skipColumns?.[table.getShortestName()];
+            if (skipColumns) {
+                table.getColumns().forEach((col) => {
+                    if (skipColumns.includes(col.name)) {
+                        table.removeColumn(col.name);
+                    }
+                });
+            }
+            return table.getEntityDeclaration(this.namingStrategy, this.helper, options.scalarPropertiesForRelations);
+        });
+        for (const meta of metadata) {
+            for (const prop of meta.relations) {
+                if (options.skipTables?.includes(prop.referencedTableName)) {
+                    prop.kind = core_1.ReferenceKind.SCALAR;
+                    const meta2 = metadata.find((m) => m.className === prop.type);
+                    prop.type = meta2
+                        .getPrimaryProps()
+                        .map((pk) => pk.type)
+                        .join(" | ");
+                }
+            }
+        }
+        metadata = metadata.filter((table) => !options.skipTables || !options.skipTables.includes(table.tableName));
+        await options.onInitialMetadata?.(metadata, this.platform);
+        this.detectManyToManyRelations(metadata, options.onlyPurePivotTables, options.readOnlyPivotTables);
+        if (options.bidirectionalRelations) {
+            this.generateBidirectionalRelations(metadata);
+        }
+        if (options.identifiedReferences) {
+            this.generateIdentifiedReferences(metadata);
+        }
+        if (options.customBaseEntityName) {
+            this.generateAndAttachCustomBaseEntity(metadata, options.customBaseEntityName);
+        }
+        // enforce schema usage in class names only on duplicates
+        const duplicates = core_1.Utils.findDuplicates(metadata.map((meta) => meta.className));
+        for (const duplicate of duplicates) {
+            for (const meta of metadata.filter((meta) => meta.className === duplicate)) {
+                meta.className = this.namingStrategy.getEntityName(`${meta.schema}_${meta.className}`);
+                metadata.forEach((meta) => meta.relations.forEach((prop) => {
+                    if (prop.type === duplicate) {
+                        prop.type = meta.className;
+                    }
+                }));
+            }
+        }
+        await options.onProcessedMetadata?.(metadata, this.platform);
+        return metadata;
+    }
+    detectManyToManyRelations(metadata, onlyPurePivotTables, readOnlyPivotTables) {
+        for (const meta of metadata) {
+            const isReferenced = metadata.some((m) => {
+                return (m.tableName !== meta.tableName &&
+                    m.relations.some((r) => {
+                        return (r.referencedTableName === meta.tableName &&
+                            [core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(r.kind));
+                    }));
+            });
+            if (isReferenced) {
+                this.referencedEntities.add(meta);
+            }
+            // Entities with non-composite PKs are never pivot tables. Skip.
+            if (!meta.compositePK) {
+                continue;
+            }
+            // Entities where there are not exactly 2 PK relations that are both ManyToOne are never pivot tables. Skip.
+            const pkRelations = meta.relations.filter((rel) => rel.primary);
+            if (pkRelations.length !== 2 ||
+                pkRelations.some((rel) => rel.kind !== core_1.ReferenceKind.MANY_TO_ONE)) {
+                continue;
+            }
+            const pkRelationFields = new Set(pkRelations.flatMap((rel) => rel.fieldNames));
+            const nonPkFields = Array.from(new Set(meta.props.flatMap((prop) => prop.fieldNames))).filter((fieldName) => !pkRelationFields.has(fieldName));
+            let fixedOrderColumn;
+            let isReadOnly = false;
+            // If there are any fields other than the ones in the two PK relations, table may or may not be a pivot one.
+            // Check further and skip on disqualification.
+            if (nonPkFields.length > 0) {
+                // Additional columns have been disabled with the setting.
+                // Skip table even it otherwise would have qualified as a pivot table.
+                if (onlyPurePivotTables) {
+                    continue;
+                }
+                const pkRelationNames = pkRelations.map((rel) => rel.name);
+                let otherProps = meta.props.filter((prop) => !pkRelationNames.includes(prop.name) &&
+                    prop.persist !== false && // Skip checking non-persist props
+                    prop.fieldNames.some((fieldName) => nonPkFields.includes(fieldName)));
+                // Deal with the auto increment column first. That is the column used for fixed ordering, if present.
+                const autoIncrementProp = meta.props.find((prop) => prop.autoincrement && prop.fieldNames.length === 1);
+                if (autoIncrementProp) {
+                    otherProps = otherProps.filter((prop) => prop !== autoIncrementProp);
+                    fixedOrderColumn = autoIncrementProp.fieldNames[0];
+                }
+                isReadOnly = otherProps.some((prop) => {
+                    // If the prop is non-nullable and unique, it will trivially end up causing issues.
+                    // Mark as read only.
+                    if (!prop.nullable && prop.unique) {
+                        return true;
+                    }
+                    // Any other props need to also be optional.
+                    // Whether they have a default or are generated,
+                    // we've already checked that not explicitly setting the property means the default is either NULL,
+                    // or a non-unique non-null value, making it safe to write to pivot entity.
+                    return !prop.optional;
+                });
+                if (isReadOnly && !readOnlyPivotTables) {
+                    continue;
+                }
+                // If this now proven pivot entity has persistent props other than the fixed order column,
+                // output it, by considering it as a referenced one.
+                if (otherProps.length > 0) {
+                    this.referencedEntities.add(meta);
+                }
+            }
+            meta.pivotTable = true;
+            const owner = metadata.find((m) => m.className === meta.relations[0].type);
+            const name = this.namingStrategy.columnNameToProperty(meta.tableName.replace(new RegExp("^" + owner.tableName + "_"), ""));
+            const ownerProp = {
+                name,
+                kind: core_1.ReferenceKind.MANY_TO_MANY,
+                pivotTable: meta.tableName,
+                type: meta.relations[1].type,
+                joinColumns: meta.relations[0].fieldNames,
+                inverseJoinColumns: meta.relations[1].fieldNames,
+            };
+            if (this.referencedEntities.has(meta)) {
+                ownerProp.pivotEntity = meta.className;
+            }
+            if (fixedOrderColumn) {
+                ownerProp.fixedOrder = true;
+                ownerProp.fixedOrderColumn = fixedOrderColumn;
+            }
+            if (isReadOnly) {
+                ownerProp.persist = false;
+            }
+            owner.addProperty(ownerProp);
+        }
+    }
+    generateBidirectionalRelations(metadata) {
+        for (const meta of metadata.filter((m) => !m.pivotTable || this.referencedEntities.has(m))) {
+            for (const prop of meta.relations) {
+                const targetMeta = metadata.find((m) => m.className === prop.type);
+                const newProp = {
+                    name: prop.name + "Inverse",
+                    type: meta.className,
+                    joinColumns: prop.fieldNames,
+                    referencedTableName: meta.tableName,
+                    referencedColumnNames: core_1.Utils.flatten(targetMeta.getPrimaryProps().map((pk) => pk.fieldNames)),
+                    mappedBy: prop.name,
+                    persist: prop.persist,
+                };
+                if (prop.kind === core_1.ReferenceKind.MANY_TO_ONE) {
+                    newProp.kind = core_1.ReferenceKind.ONE_TO_MANY;
+                }
+                else if (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !prop.mappedBy) {
+                    newProp.kind = core_1.ReferenceKind.ONE_TO_ONE;
+                    newProp.nullable = true;
+                }
+                else if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && !prop.mappedBy) {
+                    newProp.kind = core_1.ReferenceKind.MANY_TO_MANY;
+                }
+                else {
+                    continue;
+                }
+                targetMeta.addProperty(newProp);
+            }
+        }
+    }
+    generateIdentifiedReferences(metadata) {
+        for (const meta of metadata.filter((m) => !m.pivotTable || this.referencedEntities.has(m))) {
+            for (const prop of Object.values(meta.properties)) {
+                if ([core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) ||
+                    prop.lazy) {
+                    prop.ref = true;
+                }
+            }
+        }
+    }
+    generateAndAttachCustomBaseEntity(metadata, customBaseEntityName) {
+        let baseClassExists = false;
+        for (const meta of metadata) {
+            if (meta.className === customBaseEntityName) {
+                baseClassExists = true;
+                continue;
+            }
+            meta.extends ??= customBaseEntityName;
+        }
+        if (!baseClassExists) {
+            metadata.push(new core_1.EntityMetadata({
+                className: customBaseEntityName,
+                abstract: true,
+                relations: [],
+            }));
+        }
+    }
+}
+exports.EntityGenerator = EntityGenerator;

package/EntitySchemaSourceFile.d.ts

@@ -0,0 +1,8 @@
+import { type Dictionary, type EntityProperty } from "@yandjin-mikro-orm/core";
+import { SourceFile } from "./SourceFile";
+export declare class EntitySchemaSourceFile extends SourceFile {
+    generate(): string;
+    private getPropertyOptions;
+    protected getPropertyIndexesOptions(prop: EntityProperty, options: Dictionary): void;
+    protected getScalarPropertyDecoratorOptions(options: Dictionary, prop: EntityProperty): void;
+}

package/EntitySchemaSourceFile.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntitySchemaSourceFile = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const SourceFile_1 = require("./SourceFile");
+class EntitySchemaSourceFile extends SourceFile_1.SourceFile {
+    generate() {
+        this.coreImports.add("EntitySchema");
+        let classBody = "";
+        if (this.meta.className === this.options.customBaseEntityName) {
+            this.coreImports.add("Config");
+            this.coreImports.add("DefineConfig");
+            const defineConfigTypeSettings = {};
+            defineConfigTypeSettings.forceObject =
+                this.platform.getConfig().get("serialization").forceObject ?? false;
+            classBody += `${" ".repeat(2)}[Config]?: DefineConfig<${this.serializeObject(defineConfigTypeSettings)}>;\n`;
+        }
+        const enumDefinitions = [];
+        const eagerProperties = [];
+        const primaryProps = [];
+        const props = [];
+        for (const prop of Object.values(this.meta.properties)) {
+            props.push(this.getPropertyDefinition(prop, 2));
+            if (prop.enum) {
+                const enumClassName = this.namingStrategy.getClassName(this.meta.collection + "_" + prop.fieldNames[0], "_");
+                enumDefinitions.push(this.getEnumClassDefinition(enumClassName, prop.items, 2));
+            }
+            if (prop.eager) {
+                eagerProperties.push(prop);
+            }
+            if (prop.primary &&
+                (!["id", "_id", "uuid"].includes(prop.name) || this.meta.compositePK)) {
+                primaryProps.push(prop);
+            }
+        }
+        if (primaryProps.length > 0) {
+            this.coreImports.add("PrimaryKeyProp");
+            const primaryPropNames = primaryProps.map((prop) => `'${prop.name}'`);
+            if (primaryProps.length > 1) {
+                classBody += `${" ".repeat(2)}[PrimaryKeyProp]?: [${primaryPropNames.join(", ")}];\n`;
+            }
+            else {
+                classBody += `${" ".repeat(2)}[PrimaryKeyProp]?: ${primaryPropNames[0]};\n`;
+            }
+        }
+        if (eagerProperties.length > 0) {
+            this.coreImports.add("EagerProps");
+            const eagerPropertyNames = eagerProperties
+                .map((prop) => `'${prop.name}'`)
+                .sort();
+            classBody += `${" ".repeat(2)}[EagerProps]?: ${eagerPropertyNames.join(" | ")};\n`;
+        }
+        classBody += `${props.join("")}`;
+        const classDecl = this.getEntityClass(classBody);
+        let ret = `${this.generateImports()}\n\n${classDecl}`;
+        if (enumDefinitions.length) {
+            ret += "\n" + enumDefinitions.join("\n");
+        }
+        ret += `\n`;
+        ret += `export const ${this.meta.className}Schema = new EntitySchema({\n`;
+        ret += `  class: ${this.meta.className},\n`;
+        if (this.meta.tableName &&
+            this.meta.tableName !==
+                this.namingStrategy.classToTableName(this.meta.className)) {
+            ret += `  tableName: ${this.quote(this.meta.tableName)},\n`;
+        }
+        /* istanbul ignore next */
+        if (this.meta.schema &&
+            this.meta.schema !== this.platform.getDefaultSchemaName()) {
+            ret += `  schema: ${this.quote(this.meta.schema)},\n`;
+        }
+        if (this.meta.indexes.length > 0) {
+            ret += `  indexes: [\n`;
+            this.meta.indexes.forEach((index) => {
+                if (index.expression) {
+                    ret += `    { name: '${index.name}', expression: ${this.quote(index.expression)} },\n`;
+                    return;
+                }
+                const properties = core_1.Utils.asArray(index.properties).map((prop) => `'${prop}'`);
+                ret += `    { name: '${index.name}', properties: [${properties.join(", ")}] },\n`;
+            });
+            ret += `  ],\n`;
+        }
+        if (this.meta.uniques.length > 0) {
+            ret += `  uniques: [\n`;
+            this.meta.uniques.forEach((index) => {
+                if (index.expression) {
+                    ret += `    { name: '${index.name}', expression: ${this.quote(index.expression)} },\n`;
+                    return;
+                }
+                const properties = core_1.Utils.asArray(index.properties).map((prop) => `'${prop}'`);
+                ret += `    { name: '${index.name}', properties: [${properties.join(", ")}] },\n`;
+            });
+            ret += `  ],\n`;
+        }
+        ret += `  properties: {\n`;
+        Object.values(this.meta.properties).forEach((prop) => {
+            const options = this.getPropertyOptions(prop);
+            let def = this.serializeObject(options);
+            if (def.length > 80) {
+                def = this.serializeObject(options, 2);
+            }
+            //
+            ret += `    ${prop.name}: ${def},\n`;
+        });
+        ret += `  },\n`;
+        ret += `});\n`;
+        return ret;
+    }
+    getPropertyOptions(prop) {
+        const options = {};
+        if (prop.primary) {
+            options.primary = true;
+        }
+        if (typeof prop.kind !== "undefined" &&
+            prop.kind !== core_1.ReferenceKind.SCALAR) {
+            options.kind = this.quote(prop.kind);
+        }
+        if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY) {
+            this.getManyToManyDecoratorOptions(options, prop);
+        }
+        else if (prop.kind === core_1.ReferenceKind.ONE_TO_MANY) {
+            this.getOneToManyDecoratorOptions(options, prop);
+        }
+        else if (prop.kind === core_1.ReferenceKind.SCALAR ||
+            typeof prop.kind === "undefined") {
+            this.getScalarPropertyDecoratorOptions(options, prop);
+        }
+        else if (prop.kind === core_1.ReferenceKind.EMBEDDED) {
+            this.getEmbeddedPropertyDeclarationOptions(options, prop);
+        }
+        else {
+            this.getForeignKeyDecoratorOptions(options, prop);
+        }
+        if (prop.enum) {
+            options.enum = true;
+            options.items = `() => ${prop.type}`;
+        }
+        if (prop.formula) {
+            options.formula = `${prop.formula}`;
+        }
+        this.getCommonDecoratorOptions(options, prop);
+        this.getPropertyIndexesOptions(prop, options);
+        return options;
+    }
+    getPropertyIndexesOptions(prop, options) {
+        if (prop.kind === core_1.ReferenceKind.SCALAR) {
+            if (prop.index) {
+                options.index = this.quote(prop.index);
+            }
+            if (prop.unique) {
+                options.unique = this.quote(prop.unique);
+            }
+            return;
+        }
+        const processIndex = (type) => {
+            if (!prop[type]) {
+                return;
+            }
+            const defaultName = this.platform.getIndexName(this.meta.collection, prop.fieldNames, type);
+            /* istanbul ignore next */
+            options[type] = defaultName === prop[type] ? "true" : `'${prop[type]}'`;
+            const expected = {
+                index: this.platform.indexForeignKeys(),
+                unique: prop.kind === core_1.ReferenceKind.ONE_TO_ONE,
+            };
+            if (expected[type] && options[type] === "true") {
+                delete options[type];
+            }
+        };
+        processIndex("index");
+        processIndex("unique");
+    }
+    getScalarPropertyDecoratorOptions(options, prop) {
+        if (prop.kind === core_1.ReferenceKind.SCALAR && !prop.enum) {
+            options.type = this.quote(prop.type);
+        }
+        super.getScalarPropertyDecoratorOptions(options, prop);
+    }
+}
+exports.EntitySchemaSourceFile = EntitySchemaSourceFile;

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Martin Adámek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.