@yandjin-mikro-orm/core 6.1.4-rc-sti-changes-1

package/logging/DefaultLogger.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultLogger = void 0;
+const colors_1 = require("./colors");
+class DefaultLogger {
+    options;
+    debugMode;
+    writer;
+    usesReplicas;
+    highlighter;
+    constructor(options) {
+        this.options = options;
+        this.debugMode = this.options.debugMode ?? false;
+        this.writer = this.options.writer;
+        this.usesReplicas = this.options.usesReplicas;
+        this.highlighter = this.options.highlighter;
+    }
+    /**
+     * @inheritDoc
+     */
+    log(namespace, message, context) {
+        if (!this.isEnabled(namespace, context)) {
+            return;
+        }
+        // clean up the whitespace
+        message = message.replace(/\n/g, '').replace(/ +/g, ' ').trim();
+        // use red for error levels
+        if (context?.level === 'error') {
+            message = colors_1.colors.red(message);
+        }
+        // use yellow for warning levels
+        if (context?.level === 'warning') {
+            message = colors_1.colors.yellow(message);
+        }
+        const label = context?.label
+            ? colors_1.colors.cyan(`(${context.label}) `)
+            : '';
+        this.writer(colors_1.colors.grey(`[${namespace}] `) + label + message);
+    }
+    /**
+     * @inheritDoc
+     */
+    error(namespace, message, context) {
+        this.log(namespace, message, { ...context, level: 'error' });
+    }
+    /**
+     * @inheritDoc
+     */
+    warn(namespace, message, context) {
+        this.log(namespace, message, { ...context, level: 'warning' });
+    }
+    /**
+     * @inheritDoc
+     */
+    setDebugMode(debugMode) {
+        this.debugMode = debugMode;
+    }
+    isEnabled(namespace, context) {
+        if (context?.enabled !== undefined) {
+            return context.enabled;
+        }
+        const debugMode = context?.debugMode ?? this.debugMode;
+        return !!debugMode && (!Array.isArray(debugMode) || debugMode.includes(namespace));
+    }
+    /**
+     * @inheritDoc
+     */
+    logQuery(context) {
+        if (!this.isEnabled('query', context)) {
+            return;
+        }
+        /* istanbul ignore next */
+        let msg = this.highlighter?.highlight(context.query) ?? context.query;
+        if (context.took != null) {
+            const meta = [`took ${context.took} ms`];
+            if (context.results != null) {
+                meta.push(`${context.results} result${context.results === 0 || context.results > 1 ? 's' : ''}`);
+            }
+            if (context.affected != null) {
+                meta.push(`${context.affected} row${context.affected === 0 || context.affected > 1 ? 's' : ''} affected`);
+            }
+            msg += colors_1.colors.grey(` [${meta.join(', ')}]`);
+        }
+        if (this.usesReplicas && context.connection) {
+            msg += colors_1.colors.cyan(` (via ${context.connection.type} connection '${context.connection.name}')`);
+        }
+        return this.log('query', msg, context);
+    }
+}
+exports.DefaultLogger = DefaultLogger;

package/logging/Logger.d.ts

@@ -0,0 +1,56 @@
+import type { Dictionary, Highlighter } from '../typings';
+export interface Logger {
+    /**
+     * Logs a message inside given namespace.
+     */
+    log(namespace: LoggerNamespace, message: string, context?: LogContext): void;
+    /**
+     * Logs error message inside given namespace.
+     */
+    error(namespace: LoggerNamespace, message: string, context?: LogContext): void;
+    /**
+     * Logs warning message inside given namespace.
+     */
+    warn(namespace: LoggerNamespace, message: string, context?: LogContext): void;
+    /**
+     * Logs a message inside given namespace.
+     */
+    logQuery(context: LogContext): void;
+    /**
+     * Sets active namespaces. Pass `true` to enable all logging.
+     */
+    setDebugMode(debugMode: boolean | LoggerNamespace[]): void;
+    isEnabled(namespace: LoggerNamespace, context?: LogContext): boolean;
+}
+export type LoggerNamespace = 'query' | 'query-params' | 'schema' | 'discovery' | 'info';
+export interface LogContext extends Dictionary {
+    query?: string;
+    label?: string;
+    params?: unknown[];
+    took?: number;
+    results?: number;
+    affected?: number;
+    level?: 'info' | 'warning' | 'error';
+    enabled?: boolean;
+    debugMode?: LoggerNamespace[];
+    connection?: {
+        type?: string;
+        name?: string;
+    };
+}
+export interface LoggerOptions {
+    writer: (message: string) => void;
+    debugMode?: boolean | LoggerNamespace[];
+    highlighter?: Highlighter;
+    usesReplicas?: boolean;
+}
+/**
+ * Logger options to modify format output and overrides, including a label and additional properties that can be accessed by custom loggers.
+ *
+ * Differs from {@apilink LoggerOptions} in terms of how they are used; this type is primarily a public type meant to be used within methods like `em.find()`.
+ *
+ * @example
+ * await em.findOne(User, 1, { logger: { label: 'user middleware' } };
+ * // [query] (user middleware) select * from user where id = 1;
+ */
+export type LoggingOptions = Pick<LogContext, 'label' | 'enabled' | 'debugMode'>;

package/logging/Logger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/logging/SimpleLogger.d.ts

@@ -0,0 +1,17 @@
+import type { LogContext, LoggerNamespace } from './Logger';
+import { DefaultLogger } from './DefaultLogger';
+/**
+ * A basic logger that provides fully formatted output without color
+ */
+export declare class SimpleLogger extends DefaultLogger {
+    /**
+     * @inheritDoc
+     */
+    log(namespace: LoggerNamespace, message: string, context?: LogContext): void;
+    /**
+     * @inheritDoc
+     */
+    logQuery(context: {
+        query: string;
+    } & LogContext): void;
+}

package/logging/SimpleLogger.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleLogger = void 0;
+const DefaultLogger_1 = require("./DefaultLogger");
+/**
+ * A basic logger that provides fully formatted output without color
+ */
+class SimpleLogger extends DefaultLogger_1.DefaultLogger {
+    /**
+     * @inheritDoc
+     */
+    log(namespace, message, context) {
+        if (!this.isEnabled(namespace, context)) {
+            return;
+        }
+        // clean up the whitespace
+        message = message.replace(/\n/g, '').replace(/ +/g, ' ').trim();
+        const label = context?.label ? `(${context.label}) ` : '';
+        this.writer(`[${namespace}] ${label}${message}`);
+    }
+    /**
+     * @inheritDoc
+     */
+    logQuery(context) {
+        if (!this.isEnabled('query', context)) {
+            return;
+        }
+        return this.log('query', context.query, context);
+    }
+}
+exports.SimpleLogger = SimpleLogger;

package/logging/colors.d.ts

@@ -0,0 +1,9 @@
+/** @internal */
+export declare const colors: {
+    red: (text: string) => string;
+    green: (text: string) => string;
+    yellow: (text: string) => string;
+    grey: (text: string) => string;
+    cyan: (text: string) => string;
+    enabled: () => boolean | "" | undefined;
+};

package/logging/colors.js

@@ -0,0 +1,20 @@
+"use strict";
+/* istanbul ignore file */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = void 0;
+const bool = (v) => v && ['true', 't', '1'].includes(v.toLowerCase());
+const boolIfDefined = (v) => v != null ? bool(v) : true;
+const enabled = () => !bool(process.env.NO_COLOR)
+    && !bool(process.env.MIKRO_ORM_NO_COLOR)
+    && boolIfDefined(process.env.FORCE_COLOR)
+    && boolIfDefined(process.env.MIKRO_ORM_COLORS);
+const wrap = (fn) => (text) => enabled() ? fn(text) : text;
+/** @internal */
+exports.colors = {
+    red: wrap((text) => `\x1B[31m${text}\x1B[39m`),
+    green: wrap((text) => `\x1B[32m${text}\x1B[39m`),
+    yellow: wrap((text) => `\x1B[33m${text}\x1B[39m`),
+    grey: wrap((text) => `\x1B[90m${text}\x1B[39m`),
+    cyan: wrap((text) => `\x1B[36m${text}\x1B[39m`),
+    enabled,
+};

package/logging/index.d.ts

@@ -0,0 +1,4 @@
+export * from './colors';
+export * from './Logger';
+export * from './DefaultLogger';
+export * from './SimpleLogger';

package/logging/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./colors"), exports);
+__exportStar(require("./Logger"), exports);
+__exportStar(require("./DefaultLogger"), exports);
+__exportStar(require("./SimpleLogger"), exports);

package/metadata/EntitySchema.d.ts

@@ -0,0 +1,74 @@
+import { EntityMetadata, type AnyEntity, type EntityKey, type Constructor, type DeepPartial, type EntityName, type EntityProperty, type CleanKeys, type ExpandProperty, type IsNever, type EntityClass } from '../typings';
+import type { EmbeddedOptions, EnumOptions, IndexOptions, ManyToManyOptions, ManyToOneOptions, OneToManyOptions, OneToOneOptions, PrimaryKeyOptions, PropertyOptions, SerializedPrimaryKeyOptions, UniqueOptions } from '../decorators';
+import { ReferenceKind } from '../enums';
+import { Type } from '../types';
+type TypeType = string | NumberConstructor | StringConstructor | BooleanConstructor | DateConstructor | ArrayConstructor | Constructor<Type<any>> | Type<any>;
+type TypeDef<Target> = {
+    type: TypeType;
+} | {
+    entity: string | (() => string | EntityName<Target>);
+};
+export type EntitySchemaProperty<Target, Owner> = ({
+    kind: ReferenceKind.MANY_TO_ONE | 'm:1';
+} & TypeDef<Target> & ManyToOneOptions<Owner, Target>) | ({
+    kind: ReferenceKind.ONE_TO_ONE | '1:1';
+} & TypeDef<Target> & OneToOneOptions<Owner, Target>) | ({
+    kind: ReferenceKind.ONE_TO_MANY | '1:m';
+} & TypeDef<Target> & OneToManyOptions<Owner, Target>) | ({
+    kind: ReferenceKind.MANY_TO_MANY | 'm:n';
+} & TypeDef<Target> & ManyToManyOptions<Owner, Target>) | ({
+    kind: ReferenceKind.EMBEDDED | 'embedded';
+} & TypeDef<Target> & EmbeddedOptions & PropertyOptions<Owner>) | ({
+    enum: true;
+} & EnumOptions<Owner>) | (TypeDef<Target> & PropertyOptions<Owner>);
+type OmitBaseProps<Entity, Base> = IsNever<Base> extends true ? Entity : Omit<Entity, keyof Base>;
+export type EntitySchemaMetadata<Entity, Base = never> = Omit<Partial<EntityMetadata<Entity>>, 'name' | 'properties' | 'extends'> & ({
+    name: string;
+} | {
+    class: EntityClass<Entity>;
+    name?: string;
+}) & {
+    extends?: string | EntitySchema<Base>;
+} & {
+    properties?: {
+        [Key in keyof OmitBaseProps<Entity, Base> as CleanKeys<OmitBaseProps<Entity, Base>, Key>]-?: EntitySchemaProperty<ExpandProperty<NonNullable<Entity[Key]>>, Entity>;
+    };
+};
+export declare class EntitySchema<Entity = any, Base = never> {
+    /**
+     * When schema links the entity class via `class` option, this registry allows the lookup from opposite side,
+     * so we can use the class in `entities` option just like the EntitySchema instance.
+     */
+    static REGISTRY: Map<Partial<any>, EntitySchema<any, never>>;
+    private readonly _meta;
+    private internal;
+    private initialized;
+    constructor(meta: EntitySchemaMetadata<Entity, Base>);
+    static fromMetadata<T = AnyEntity, U = never>(meta: EntityMetadata<T> | DeepPartial<EntityMetadata<T>>): EntitySchema<T, U>;
+    addProperty(name: EntityKey<Entity>, type?: TypeType, options?: PropertyOptions<Entity> | EntityProperty<Entity>): void;
+    addEnum(name: EntityKey<Entity>, type?: TypeType, options?: EnumOptions<Entity>): void;
+    addVersion(name: EntityKey<Entity>, type: TypeType, options?: PropertyOptions<Entity>): void;
+    addPrimaryKey(name: EntityKey<Entity>, type: TypeType, options?: PrimaryKeyOptions<Entity>): void;
+    addSerializedPrimaryKey(name: EntityKey<Entity>, type: TypeType, options?: SerializedPrimaryKeyOptions<Entity>): void;
+    addEmbedded<Target = AnyEntity>(name: EntityKey<Entity>, options: EmbeddedOptions): void;
+    addManyToOne<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: ManyToOneOptions<Entity, Target>): void;
+    addManyToMany<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: ManyToManyOptions<Entity, Target>): void;
+    addOneToMany<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: OneToManyOptions<Entity, Target>): void;
+    addOneToOne<Target = AnyEntity>(name: EntityKey<Entity>, type: TypeType, options: OneToOneOptions<Entity, Target>): void;
+    addIndex(options: IndexOptions<Entity>): void;
+    addUnique(options: UniqueOptions<Entity>): void;
+    setCustomRepository(repository: () => Constructor): void;
+    setExtends(base: string | EntitySchema): void;
+    setClass(proto: EntityClass<Entity>): void;
+    get meta(): EntityMetadata<Entity>;
+    get name(): EntityName<Entity>;
+    /**
+     * @internal
+     */
+    init(): this;
+    private initProperties;
+    private initPrimaryKeys;
+    private normalizeType;
+    private createProperty;
+}
+export {};

package/metadata/EntitySchema.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntitySchema = void 0;
+const typings_1 = require("../typings");
+const BaseEntity_1 = require("../entity/BaseEntity");
+const enums_1 = require("../enums");
+const types_1 = require("../types");
+const utils_1 = require("../utils");
+const EnumArrayType_1 = require("../types/EnumArrayType");
+class EntitySchema {
+    /**
+     * When schema links the entity class via `class` option, this registry allows the lookup from opposite side,
+     * so we can use the class in `entities` option just like the EntitySchema instance.
+     */
+    static REGISTRY = new Map();
+    _meta = new typings_1.EntityMetadata();
+    internal = false;
+    initialized = false;
+    constructor(meta) {
+        meta.name = meta.class ? meta.class.name : meta.name;
+        if (meta.name) {
+            meta.abstract ??= false;
+        }
+        if (meta.class && !meta.internal) {
+            EntitySchema.REGISTRY.set(meta.class, this);
+        }
+        if (meta.tableName || meta.collection) {
+            utils_1.Utils.renameKey(meta, 'tableName', 'collection');
+            meta.tableName = meta.collection;
+        }
+        Object.assign(this._meta, { className: meta.name }, meta);
+        this._meta.root ??= this._meta;
+    }
+    static fromMetadata(meta) {
+        const schema = new EntitySchema({ ...meta, internal: true });
+        schema.internal = true;
+        return schema;
+    }
+    addProperty(name, type, options = {}) {
+        const rename = (data, from, to) => {
+            if (from in options && !(to in options)) {
+                // @ts-ignore
+                options[to] = [options[from]];
+                // @ts-ignore
+                delete options[from];
+            }
+        };
+        if (name !== options.name) {
+            utils_1.Utils.renameKey(options, 'name', 'fieldName');
+        }
+        rename(options, 'fieldName', 'fieldNames');
+        rename(options, 'ref', 'ref');
+        rename(options, 'joinColumn', 'joinColumns');
+        rename(options, 'inverseJoinColumn', 'inverseJoinColumns');
+        rename(options, 'referenceColumnName', 'referencedColumnNames');
+        rename(options, 'columnType', 'columnTypes');
+        const prop = { name, kind: enums_1.ReferenceKind.SCALAR, ...options, type: this.normalizeType(options, type) };
+        if (type && types_1.Type.isMappedType(type.prototype)) {
+            prop.type = type;
+        }
+        if (utils_1.Utils.isString(prop.formula)) {
+            const formula = prop.formula; // tmp var is needed here
+            prop.formula = () => formula;
+        }
+        if (prop.formula) {
+            prop.persist ??= false;
+        }
+        this._meta.properties[name] = prop;
+    }
+    addEnum(name, type, options = {}) {
+        if (options.items instanceof Function) {
+            options.items = utils_1.Utils.extractEnumValues(options.items());
+        }
+        // enum arrays are simple numeric/string arrays, the constraint is enforced in the custom type only
+        if (options.array && !options.type) {
+            options.type = new EnumArrayType_1.EnumArrayType(`${this._meta.className}.${name}`, options.items);
+            options.enum = false;
+        }
+        const prop = { enum: true, ...options };
+        if (prop.array) {
+            prop.enum = false;
+        }
+        // force string labels on native enums
+        if (prop.nativeEnumName && Array.isArray(prop.items)) {
+            prop.items = prop.items.map(val => '' + val);
+        }
+        this.addProperty(name, this.internal ? type : type || 'enum', prop);
+    }
+    addVersion(name, type, options = {}) {
+        this.addProperty(name, type, { version: true, ...options });
+    }
+    addPrimaryKey(name, type, options = {}) {
+        this.addProperty(name, type, { primary: true, ...options });
+    }
+    addSerializedPrimaryKey(name, type, options = {}) {
+        this._meta.serializedPrimaryKey = name;
+        this.addProperty(name, type, options);
+    }
+    addEmbedded(name, options) {
+        utils_1.Utils.defaultValue(options, 'prefix', true);
+        if (options.array) {
+            options.object = true; // force object mode for arrays
+        }
+        this._meta.properties[name] = {
+            name,
+            type: this.normalizeType(options),
+            kind: enums_1.ReferenceKind.EMBEDDED,
+            ...options,
+        };
+    }
+    addManyToOne(name, type, options) {
+        const prop = this.createProperty(enums_1.ReferenceKind.MANY_TO_ONE, options);
+        prop.owner = true;
+        if (prop.joinColumns && !prop.fieldNames) {
+            prop.fieldNames = prop.joinColumns;
+        }
+        if (prop.fieldNames && !prop.joinColumns) {
+            prop.joinColumns = prop.fieldNames;
+        }
+        this.addProperty(name, type, prop);
+    }
+    addManyToMany(name, type, options) {
+        options.fixedOrder = options.fixedOrder || !!options.fixedOrderColumn;
+        if (!options.owner && !options.mappedBy) {
+            options.owner = true;
+        }
+        if (options.owner) {
+            utils_1.Utils.renameKey(options, 'mappedBy', 'inversedBy');
+        }
+        const prop = this.createProperty(enums_1.ReferenceKind.MANY_TO_MANY, options);
+        this.addProperty(name, type, prop);
+    }
+    addOneToMany(name, type, options) {
+        const prop = this.createProperty(enums_1.ReferenceKind.ONE_TO_MANY, options);
+        this.addProperty(name, type, prop);
+    }
+    addOneToOne(name, type, options) {
+        const prop = this.createProperty(enums_1.ReferenceKind.ONE_TO_ONE, options);
+        utils_1.Utils.defaultValue(prop, 'owner', !!prop.inversedBy || !prop.mappedBy);
+        utils_1.Utils.defaultValue(prop, 'unique', prop.owner);
+        if (prop.owner && options.mappedBy) {
+            utils_1.Utils.renameKey(prop, 'mappedBy', 'inversedBy');
+        }
+        if (prop.joinColumns && !prop.fieldNames) {
+            prop.fieldNames = prop.joinColumns;
+        }
+        if (prop.fieldNames && !prop.joinColumns) {
+            prop.joinColumns = prop.fieldNames;
+        }
+        this.addProperty(name, type, prop);
+    }
+    addIndex(options) {
+        this._meta.indexes.push(options);
+    }
+    addUnique(options) {
+        this._meta.uniques.push(options);
+    }
+    setCustomRepository(repository) {
+        this._meta.repository = repository;
+    }
+    setExtends(base) {
+        this._meta.extends = base;
+    }
+    setClass(proto) {
+        this._meta.class = proto;
+        this._meta.prototype = proto.prototype;
+        this._meta.className = proto.name;
+        const tokens = utils_1.Utils.tokenize(proto);
+        this._meta.constructorParams = utils_1.Utils.getParamNames(tokens, 'constructor');
+        this._meta.toJsonParams = utils_1.Utils.getParamNames(tokens, 'toJSON').filter(p => p !== '...args');
+        if (!this.internal) {
+            EntitySchema.REGISTRY.set(proto, this);
+        }
+        if (Object.getPrototypeOf(proto) !== BaseEntity_1.BaseEntity) {
+            this._meta.extends = this._meta.extends || Object.getPrototypeOf(proto).name || undefined;
+        }
+    }
+    get meta() {
+        return this._meta;
+    }
+    get name() {
+        return this._meta.className;
+    }
+    /**
+     * @internal
+     */
+    init() {
+        if (this.initialized) {
+            return this;
+        }
+        if (!this._meta.class) {
+            const name = this.name;
+            this._meta.class = ({ [name]: class {
+                } })[name];
+        }
+        this.setClass(this._meta.class);
+        if (this._meta.abstract && !this._meta.discriminatorColumn) {
+            delete this._meta.name;
+        }
+        const tableName = this._meta.collection ?? this._meta.tableName;
+        if (tableName?.includes('.') && !this._meta.schema) {
+            this._meta.schema = tableName.substring(0, tableName.indexOf('.'));
+            this._meta.collection = tableName.substring(tableName.indexOf('.') + 1);
+        }
+        this.initProperties();
+        this.initPrimaryKeys();
+        this._meta.props = Object.values(this._meta.properties);
+        this._meta.relations = this._meta.props.filter(prop => typeof prop.kind !== 'undefined' && prop.kind !== enums_1.ReferenceKind.SCALAR && prop.kind !== enums_1.ReferenceKind.EMBEDDED);
+        this.initialized = true;
+        return this;
+    }
+    initProperties() {
+        utils_1.Utils.entries(this._meta.properties).forEach(([name, options]) => {
+            if (types_1.Type.isMappedType(options.type)) {
+                options.type ??= options.type.constructor.name;
+            }
+            switch (options.kind) {
+                case enums_1.ReferenceKind.ONE_TO_ONE:
+                    this.addOneToOne(name, options.type, options);
+                    break;
+                case enums_1.ReferenceKind.ONE_TO_MANY:
+                    this.addOneToMany(name, options.type, options);
+                    break;
+                case enums_1.ReferenceKind.MANY_TO_ONE:
+                    this.addManyToOne(name, options.type, options);
+                    break;
+                case enums_1.ReferenceKind.MANY_TO_MANY:
+                    this.addManyToMany(name, options.type, options);
+                    break;
+                case enums_1.ReferenceKind.EMBEDDED:
+                    this.addEmbedded(name, options);
+                    break;
+                default:
+                    if (options.enum) {
+                        this.addEnum(name, options.type, options);
+                    }
+                    else if (options.primary) {
+                        this.addPrimaryKey(name, options.type, options);
+                    }
+                    else if (options.serializedPrimaryKey) {
+                        this.addSerializedPrimaryKey(name, options.type, options);
+                    }
+                    else if (options.version) {
+                        this.addVersion(name, options.type, options);
+                    }
+                    else {
+                        this.addProperty(name, options.type, options);
+                    }
+            }
+        });
+    }
+    initPrimaryKeys() {
+        const pks = Object.values(this._meta.properties).filter(prop => prop.primary);
+        if (pks.length > 0) {
+            this._meta.primaryKeys = pks.map(prop => prop.name);
+            this._meta.compositePK = pks.length > 1;
+            this._meta.simplePK = !this._meta.compositePK && pks[0].kind === enums_1.ReferenceKind.SCALAR && !pks[0].customType;
+        }
+        if (pks.length === 1 && ['number', 'bigint'].includes(pks[0].type)) {
+            pks[0].autoincrement ??= true;
+        }
+        const serializedPrimaryKey = Object.values(this._meta.properties).find(prop => prop.serializedPrimaryKey);
+        if (serializedPrimaryKey) {
+            this._meta.serializedPrimaryKey = serializedPrimaryKey.name;
+        }
+    }
+    normalizeType(options, type) {
+        if ('entity' in options) {
+            if (utils_1.Utils.isString(options.entity)) {
+                type = options.type = options.entity;
+            }
+            else if (options.entity) {
+                const tmp = options.entity();
+                type = options.type = Array.isArray(tmp) ? tmp.map(t => utils_1.Utils.className(t)).sort().join(' | ') : utils_1.Utils.className(tmp);
+            }
+        }
+        if (type instanceof Function) {
+            type = type.name;
+        }
+        if (['String', 'Number', 'Boolean', 'Array'].includes(type)) {
+            type = type.toLowerCase();
+        }
+        return type;
+    }
+    createProperty(kind, options) {
+        return {
+            kind,
+            cascade: [enums_1.Cascade.PERSIST],
+            ...options,
+        };
+    }
+}
+exports.EntitySchema = EntitySchema;