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

package/SourceFile.js

@@ -0,0 +1,583 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceFile = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+/**
+ * @see https://github.com/tc39/proposal-regexp-unicode-property-escapes#other-examples
+ */
+const identifierRegex = /^(?:[$_\p{ID_Start}])(?:[$\u200C\u200D\p{ID_Continue}])*$/u;
+class SourceFile {
+    meta;
+    namingStrategy;
+    platform;
+    options;
+    coreImports = new Set();
+    entityImports = new Set();
+    constructor(meta, namingStrategy, platform, options) {
+        this.meta = meta;
+        this.namingStrategy = namingStrategy;
+        this.platform = platform;
+        this.options = options;
+    }
+    generate() {
+        let ret = "";
+        if (this.meta.embeddable || this.meta.collection) {
+            if (this.meta.embeddable) {
+                this.coreImports.add("Embeddable");
+                ret += `@Embeddable(${this.getEmbeddableDeclOptions()})\n`;
+            }
+            else {
+                this.coreImports.add("Entity");
+                ret += `@Entity(${this.getEntityDeclOptions()})\n`;
+            }
+        }
+        this.meta.indexes.forEach((index) => {
+            this.coreImports.add("Index");
+            if (index.expression) {
+                ret += `@Index({ name: '${index.name}', expression: ${this.quote(index.expression)} })\n`;
+                return;
+            }
+            const properties = core_1.Utils.asArray(index.properties).map((prop) => this.quote("" + prop));
+            ret += `@Index({ name: '${index.name}', properties: [${properties.join(", ")}] })\n`;
+        });
+        this.meta.uniques.forEach((index) => {
+            this.coreImports.add("Unique");
+            if (index.expression) {
+                ret += `@Unique({ name: '${index.name}', expression: ${this.quote(index.expression)} })\n`;
+                return;
+            }
+            const properties = core_1.Utils.asArray(index.properties).map((prop) => `'${prop}'`);
+            ret += `@Unique({ name: '${index.name}', properties: [${properties.join(", ")}] })\n`;
+        });
+        let classHead = "";
+        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;
+            classHead += `\n${" ".repeat(2)}[Config]?: DefineConfig<${this.serializeObject(defineConfigTypeSettings)}>;\n\n`;
+        }
+        const enumDefinitions = [];
+        const eagerProperties = [];
+        const primaryProps = [];
+        let classBody = "";
+        Object.values(this.meta.properties).forEach((prop) => {
+            const decorator = this.getPropertyDecorator(prop, 2);
+            const definition = this.getPropertyDefinition(prop, 2);
+            classBody += decorator;
+            classBody += definition;
+            classBody += "\n";
+            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) {
+                classHead += `\n${" ".repeat(2)}[PrimaryKeyProp]?: [${primaryPropNames.join(", ")}];\n`;
+            }
+            else {
+                classHead += `\n${" ".repeat(2)}[PrimaryKeyProp]?: ${primaryPropNames[0]};\n`;
+            }
+        }
+        if (eagerProperties.length > 0) {
+            this.coreImports.add("EagerProps");
+            const eagerPropertyNames = eagerProperties
+                .map((prop) => `'${prop.name}'`)
+                .sort();
+            classHead += `\n${" ".repeat(2)}[EagerProps]?: ${eagerPropertyNames.join(" | ")};\n`;
+        }
+        ret += this.getEntityClass(classBody ? `${classHead}\n${classBody}` : classHead);
+        ret = `${this.generateImports()}\n\n${ret}`;
+        if (enumDefinitions.length) {
+            ret += "\n" + enumDefinitions.join("\n");
+        }
+        return ret;
+    }
+    generateImports() {
+        const imports = [];
+        if (this.coreImports.size > 0) {
+            imports.push(`import { ${[...this.coreImports].sort().join(", ")} } from '@yandjin-mikro-orm/core';`);
+        }
+        const entityImportExtension = this.options.esmImport ? ".js" : "";
+        const entityImports = [...this.entityImports].filter((e) => e !== this.meta.className);
+        entityImports.sort().forEach((entity) => {
+            imports.push(`import { ${entity} } from './${this.options.fileName(entity)}${entityImportExtension}';`);
+        });
+        return imports.join("\n");
+    }
+    getEntityClass(classBody) {
+        let ret = `export `;
+        if (this.meta.abstract) {
+            ret += `abstract `;
+        }
+        ret += `class ${this.meta.className}`;
+        if (this.meta.extends) {
+            this.entityImports.add(this.meta.extends);
+            ret += ` extends ${this.meta.extends}`;
+        }
+        else if (this.options.useCoreBaseEntity) {
+            if (this.meta.className === "BaseEntity") {
+                this.coreImports.add("BaseEntity as MikroBaseEntity");
+                ret += ` extends MikroBaseEntity`;
+            }
+            else {
+                this.coreImports.add("BaseEntity");
+                ret += ` extends BaseEntity`;
+            }
+        }
+        ret += ` {\n${classBody}}\n`;
+        return ret;
+    }
+    getBaseName(extension = ".ts") {
+        return `${this.options.fileName(this.meta.className)}${extension}`;
+    }
+    quote(val) {
+        /* istanbul ignore next */
+        return val.startsWith(`'`) ? `\`${val}\`` : `'${val}'`;
+    }
+    getPropertyDefinition(prop, padLeft) {
+        const padding = " ".repeat(padLeft);
+        let hiddenType = "";
+        if (prop.hidden) {
+            this.coreImports.add("Hidden");
+            hiddenType += " & Hidden";
+        }
+        if ([core_1.ReferenceKind.ONE_TO_MANY, core_1.ReferenceKind.MANY_TO_MANY].includes(prop.kind)) {
+            this.coreImports.add("Collection");
+            this.entityImports.add(prop.type);
+            return `${padding}${prop.name}${hiddenType ? `: Collection<${prop.type}>${hiddenType}` : ""} = new Collection<${prop.type}>(this);\n`;
+        }
+        const propType = prop.mapToPk
+            ? (() => {
+                const runtimeTypes = prop.columnTypes.map((t) => this.platform.getMappedType(t).runtimeType);
+                return runtimeTypes.length === 1
+                    ? runtimeTypes[0]
+                    : this.serializeObject(runtimeTypes);
+            })()
+            : prop.type;
+        // string defaults are usually things like SQL functions, but can be also enums, for that `useDefault` should be true
+        const isEnumOrNonStringDefault = prop.enum || typeof prop.default !== "string";
+        const useDefault = prop.default != null && isEnumOrNonStringDefault;
+        const optional = prop.nullable ? "?" : useDefault ? "" : "!";
+        if (prop.ref) {
+            this.coreImports.add("Ref");
+            if (typeof prop.kind === "string" && prop.kind !== core_1.ReferenceKind.SCALAR) {
+                this.entityImports.add(propType);
+            }
+            return `${padding}${prop.name}${optional}: Ref<${propType}>${hiddenType};\n`;
+        }
+        let ret = `${prop.name}${optional}: ${propType}`;
+        if (prop.kind === core_1.ReferenceKind.EMBEDDED && prop.array) {
+            ret += "[]";
+        }
+        ret += hiddenType;
+        if (useDefault || (optional !== "?" && typeof prop.default === "string")) {
+            this.coreImports.add("Opt");
+            ret += " & Opt";
+        }
+        if (!useDefault) {
+            return `${padding}${ret};\n`;
+        }
+        if (prop.enum && typeof prop.default === "string") {
+            return `${padding}${ret} = ${propType}.${prop.default.toUpperCase()};\n`;
+        }
+        return `${padding}${ret} = ${prop.default};\n`;
+    }
+    getEnumClassDefinition(enumClassName, enumValues, padLeft) {
+        const padding = " ".repeat(padLeft);
+        let ret = `export enum ${enumClassName} {\n`;
+        for (const enumValue of enumValues) {
+            ret += `${padding}${enumValue.toUpperCase()} = '${enumValue}',\n`;
+        }
+        ret += "}\n";
+        return ret;
+    }
+    serializeObject(options, spaces) {
+        const sep = typeof spaces === "undefined" ? ", " : `,\n${" ".repeat(spaces)}`;
+        const doIndent = typeof spaces !== "undefined";
+        if (Array.isArray(options)) {
+            return `[${doIndent ? `\n${" ".repeat(spaces)}` : ""}${options.map((val) => `${doIndent ? " ".repeat(spaces) : ""}${this.serializeValue(val, doIndent ? spaces + 2 : undefined)}`).join(sep)}${doIndent ? `\n${" ".repeat(spaces + 2)}` : ""}]`;
+        }
+        return `{${doIndent ? `\n${" ".repeat(spaces)}` : " "}${Object.entries(options)
+            .map(([opt, val]) => {
+            return `${doIndent ? " ".repeat(spaces + 2) : ""}${identifierRegex.test(opt) ? opt : JSON.stringify(opt)}: ${this.serializeValue(val, doIndent ? spaces + 2 : undefined)}`;
+        })
+            .join(sep)}${doIndent ? `,\n${" ".repeat(spaces + 2)}` : " "}}`;
+    }
+    serializeValue(val, spaces) {
+        if (typeof val === "object" && val !== null) {
+            return this.serializeObject(val, spaces);
+        }
+        return val;
+    }
+    getEntityDeclOptions() {
+        const options = {};
+        if (this.meta.collection !==
+            this.namingStrategy.classToTableName(this.meta.className)) {
+            options.tableName = this.quote(this.meta.collection);
+        }
+        if (this.meta.schema &&
+            this.meta.schema !== this.platform.getDefaultSchemaName()) {
+            options.schema = this.quote(this.meta.schema);
+        }
+        if (typeof this.meta.expression === "string") {
+            options.expression = this.quote(this.meta.expression);
+        }
+        else if (typeof this.meta.expression === "function") {
+            options.expression = `${this.meta.expression}`;
+        }
+        if (this.meta.comment) {
+            options.comment = this.quote(this.meta.comment);
+        }
+        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);
+    }
+    getEmbeddableDeclOptions() {
+        const options = {};
+        return this.getCollectionDecl(options);
+    }
+    getCollectionDecl(options) {
+        if (this.meta.abstract) {
+            options.abstract = true;
+        }
+        if (this.meta.discriminatorValue) {
+            options.discriminatorValue =
+                typeof this.meta.discriminatorValue === "string"
+                    ? this.quote(this.meta.discriminatorValue)
+                    : this.meta.discriminatorValue;
+        }
+        if (this.meta.discriminatorColumn) {
+            options.discriminatorColumn = this.quote(this.meta.discriminatorColumn);
+        }
+        if (this.meta.discriminatorMap) {
+            options.discriminatorMap = Object.fromEntries(Object.entries(this.meta.discriminatorMap).map(([discriminatorValue, className]) => [
+                discriminatorValue,
+                this.quote(className),
+            ]));
+        }
+        if (!core_1.Utils.hasObjectKeys(options)) {
+            return "";
+        }
+        return this.serializeObject(options);
+    }
+    getPropertyDecorator(prop, padLeft) {
+        const padding = " ".repeat(padLeft);
+        const options = {};
+        let decorator = this.getDecoratorType(prop);
+        this.coreImports.add(decorator.substring(1));
+        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.items = `() => ${prop.type}`;
+        }
+        this.getCommonDecoratorOptions(options, prop);
+        const indexes = this.getPropertyIndexes(prop, options);
+        decorator = [...indexes.sort(), decorator]
+            .map((d) => padding + d)
+            .join("\n");
+        const decoratorArgs = [];
+        if (prop.formula) {
+            decoratorArgs.push(`${prop.formula}`);
+        }
+        if (core_1.Utils.hasObjectKeys(options)) {
+            decoratorArgs.push(`${this.serializeObject(options)}`);
+        }
+        return `${decorator}(${decoratorArgs.join(", ")})\n`;
+    }
+    getPropertyIndexes(prop, options) {
+        if (prop.kind === core_1.ReferenceKind.SCALAR) {
+            const ret = [];
+            if (prop.index) {
+                this.coreImports.add("Index");
+                ret.push(`@Index({ name: '${prop.index}' })`);
+            }
+            if (prop.unique) {
+                this.coreImports.add("Unique");
+                ret.push(`@Unique({ name: '${prop.unique}' })`);
+            }
+            return ret;
+        }
+        const processIndex = (type) => {
+            if (!prop[type]) {
+                return;
+            }
+            const defaultName = this.platform.getIndexName(this.meta.collection, prop.fieldNames, type);
+            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");
+        return [];
+    }
+    getCommonDecoratorOptions(options, prop) {
+        if (this.options.scalarTypeInDecorator &&
+            prop.kind === core_1.ReferenceKind.SCALAR &&
+            !prop.enum) {
+            options.type = this.quote(prop.type);
+        }
+        if (prop.nullable && !prop.mappedBy) {
+            options.nullable = true;
+        }
+        if (prop.persist === false) {
+            options.persist = false;
+        }
+        ["onCreate", "onUpdate", "serializer"]
+            .filter((key) => typeof prop[key] === "function")
+            .forEach((key) => (options[key] = `${prop[key]}`));
+        if (typeof prop.serializedName === "string") {
+            options.serializedName = this.quote(prop.serializedName);
+        }
+        [
+            "hidden",
+            "version",
+            "concurrencyCheck",
+            "eager",
+            "lazy",
+            "orphanRemoval",
+        ]
+            .filter((key) => prop[key])
+            .forEach((key) => (options[key] = true));
+        if (prop.cascade &&
+            (prop.cascade.length !== 1 || prop.cascade[0] !== core_1.Cascade.PERSIST)) {
+            this.coreImports.add("Cascade");
+            options.cascade = `[${prop.cascade.map((value) => "Cascade." + value.toUpperCase()).join(", ")}]`;
+        }
+        if (typeof prop.comment === "string") {
+            options.comment = this.quote(prop.comment);
+        }
+        if (prop.default == null) {
+            return;
+        }
+        if (typeof prop.default !== "string") {
+            options.default = prop.default;
+            return;
+        }
+        if ([`''`, ""].includes(prop.default)) {
+            options.default = `''`;
+        }
+        else if (prop.defaultRaw === this.quote(prop.default)) {
+            options.default = this.quote(prop.default);
+        }
+        else {
+            options.defaultRaw = `\`${prop.default}\``;
+        }
+    }
+    getScalarPropertyDecoratorOptions(options, prop) {
+        if (prop.fieldNames[0] !== this.namingStrategy.propertyToColumnName(prop.name)) {
+            options.fieldName = `'${prop.fieldNames[0]}'`;
+        }
+        // for enum properties, we don't need a column type or the property length
+        // in the decorator so return early.
+        if (prop.enum) {
+            return;
+        }
+        let t = prop.type;
+        if (t === "Date") {
+            t = "datetime";
+        }
+        const mappedType1 = this.platform.getMappedType(t);
+        const mappedType2 = this.platform.getMappedType(prop.columnTypes[0]);
+        const columnType1 = mappedType1.getColumnType({ ...prop, autoincrement: false }, this.platform);
+        const columnType2 = mappedType2.getColumnType({ ...prop, autoincrement: false }, this.platform);
+        if (columnType1 !== columnType2 ||
+            [mappedType1, mappedType2].some((t) => t instanceof core_1.UnknownType)) {
+            options.columnType = this.quote(columnType2);
+        }
+        const assign = (key) => {
+            if (prop[key] != null) {
+                options[key] = prop[key];
+            }
+        };
+        if (!(mappedType2 instanceof core_1.DateType) && !options.columnType) {
+            assign("length");
+        }
+        // those are already included in the `columnType` in most cases, and when that option is present, they would be ignored anyway
+        /* istanbul ignore next */
+        if (mappedType2 instanceof core_1.DecimalType && !options.columnType) {
+            assign("precision");
+            assign("scale");
+        }
+        if (prop.autoincrement) {
+            if (!prop.primary ||
+                !["number", "bigint"].includes(t) ||
+                this.meta.getPrimaryProps().length !== 1) {
+                options.autoincrement = true;
+            }
+        }
+        else {
+            if (prop.primary &&
+                ["number", "bigint"].includes(t) &&
+                this.meta.getPrimaryProps().length === 1) {
+                options.autoincrement = false;
+            }
+        }
+        if (prop.generated) {
+            options.generated =
+                typeof prop.generated === "string"
+                    ? this.quote(prop.generated)
+                    : `${prop.generated}`;
+        }
+    }
+    getManyToManyDecoratorOptions(options, prop) {
+        this.entityImports.add(prop.type);
+        options.entity = `() => ${prop.type}`;
+        if (prop.mappedBy) {
+            options.mappedBy = this.quote(prop.mappedBy);
+            return;
+        }
+        if (prop.pivotTable !==
+            this.namingStrategy.joinTableName(this.meta.collection, prop.type, prop.name)) {
+            options.pivotTable = this.quote(prop.pivotTable);
+        }
+        if (prop.pivotEntity && prop.pivotEntity !== prop.pivotTable) {
+            this.entityImports.add(prop.pivotEntity);
+            options.pivotEntity = `() => ${prop.pivotEntity}`;
+        }
+        if (prop.joinColumns.length === 1) {
+            options.joinColumn = this.quote(prop.joinColumns[0]);
+        }
+        else {
+            options.joinColumns = `[${prop.joinColumns.map(this.quote).join(", ")}]`;
+        }
+        if (prop.inverseJoinColumns.length === 1) {
+            options.inverseJoinColumn = this.quote(prop.inverseJoinColumns[0]);
+        }
+        else {
+            options.inverseJoinColumns = `[${prop.inverseJoinColumns.map(this.quote).join(", ")}]`;
+        }
+        if (prop.fixedOrder) {
+            options.fixedOrder = true;
+            if (prop.fixedOrderColumn &&
+                prop.fixedOrderColumn !== this.namingStrategy.referenceColumnName()) {
+                options.fixedOrderColumn = this.quote(prop.fixedOrderColumn);
+            }
+        }
+    }
+    getOneToManyDecoratorOptions(options, prop) {
+        this.entityImports.add(prop.type);
+        options.entity = `() => ${prop.type}`;
+        options.mappedBy = this.quote(prop.mappedBy);
+    }
+    getEmbeddedPropertyDeclarationOptions(options, prop) {
+        this.coreImports.add("Embedded");
+        this.entityImports.add(prop.type);
+        options.entity = `() => ${prop.type}`;
+        if (prop.array) {
+            options.array = true;
+        }
+        if (prop.object) {
+            options.object = true;
+        }
+        if (prop.prefix === false || typeof prop.prefix === "string") {
+            options.prefix = prop.prefix;
+        }
+    }
+    getForeignKeyDecoratorOptions(options, prop) {
+        const parts = prop.referencedTableName.split(".", 2);
+        const className = this.namingStrategy.getEntityName(...parts.reverse());
+        this.entityImports.add(className);
+        options.entity = `() => ${className}`;
+        if (prop.ref) {
+            options.ref = true;
+        }
+        if (prop.mapToPk) {
+            options.mapToPk = true;
+        }
+        if (prop.mappedBy) {
+            options.mappedBy = this.quote(prop.mappedBy);
+            return;
+        }
+        if (prop.fieldNames.length === 1) {
+            if (prop.fieldNames[0] !==
+                this.namingStrategy.joinKeyColumnName(prop.name, prop.referencedColumnNames[0])) {
+                options.fieldName = this.quote(prop.fieldNames[0]);
+            }
+        }
+        else {
+            if (prop.fieldNames.length > 1 &&
+                prop.fieldNames.some((fieldName, i) => fieldName !==
+                    this.namingStrategy.joinKeyColumnName(prop.name, prop.referencedColumnNames[i]))) {
+                options.fieldNames = prop.fieldNames.map((fieldName) => this.quote(fieldName));
+            }
+        }
+        if (!["no action", "restrict"].includes(prop.updateRule.toLowerCase())) {
+            options.updateRule = this.quote(prop.updateRule);
+        }
+        if (!["no action", "restrict"].includes(prop.deleteRule.toLowerCase())) {
+            options.deleteRule = this.quote(prop.deleteRule);
+        }
+        if (prop.primary) {
+            options.primary = true;
+        }
+        if (prop.generated) {
+            options.generated =
+                typeof prop.generated === "string"
+                    ? this.quote(prop.generated)
+                    : `${prop.generated}`;
+        }
+    }
+    getDecoratorType(prop) {
+        if (prop.kind === core_1.ReferenceKind.ONE_TO_ONE) {
+            return "@OneToOne";
+        }
+        if (prop.kind === core_1.ReferenceKind.MANY_TO_ONE) {
+            return "@ManyToOne";
+        }
+        if (prop.kind === core_1.ReferenceKind.ONE_TO_MANY) {
+            return "@OneToMany";
+        }
+        if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY) {
+            return "@ManyToMany";
+        }
+        if (prop.kind === core_1.ReferenceKind.EMBEDDED) {
+            return "@Embedded";
+        }
+        if (prop.primary) {
+            return "@PrimaryKey";
+        }
+        if (prop.enum) {
+            return "@Enum";
+        }
+        if (prop.formula) {
+            return "@Formula";
+        }
+        return "@Property";
+    }
+}
+exports.SourceFile = SourceFile;

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @packageDocumentation
+ * @module entity-generator
+ */
+export * from './EntityGenerator';

package/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @packageDocumentation
+ * @module entity-generator
+ */
+__exportStar(require("./EntityGenerator"), exports);

package/index.mjs

@@ -0,0 +1,4 @@
+import mod from "./index.js";
+
+export default mod;
+export const EntityGenerator = mod.EntityGenerator;

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@yandjin-mikro-orm/entity-generator",
+  "version": "6.1.4-rc-sti-changes-1",
+  "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.",
+  "main": "index.js",
+  "module": "index.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./index.mjs"
+      },
+      "require": "./index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "keywords": [
+    "orm",
+    "mongo",
+    "mongodb",
+    "mysql",
+    "mariadb",
+    "postgresql",
+    "sqlite",
+    "sqlite3",
+    "ts",
+    "typescript",
+    "js",
+    "javascript",
+    "entity",
+    "ddd",
+    "mikro-orm",
+    "unit-of-work",
+    "data-mapper",
+    "identity-map"
+  ],
+  "author": "Martin Adámek",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mikro-orm/mikro-orm/issues"
+  },
+  "homepage": "https://mikro-orm.io",
+  "engines": {
+    "node": ">= 18.12.0"
+  },
+  "scripts": {
+    "build": "yarn clean && yarn compile && yarn copy && yarn run -T gen-esm-wrapper index.js index.mjs",
+    "clean": "yarn run -T rimraf ./dist",
+    "compile": "yarn run -T tsc -p tsconfig.build.json",
+    "copy": "node ../../scripts/copy.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@yandjin-mikro-orm/knex": "6.1.4-rc-sti-changes-1",
+    "fs-extra": "11.2.0"
+  },
+  "devDependencies": {
+    "@yandjin-mikro-orm/core": "^6.1.4-rc-sti-changes-1"
+  },
+  "peerDependencies": {
+    "@yandjin-mikro-orm/core": "^6.0.0"
+  }
+}