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

package/metadata/MetadataProvider.d.ts

@@ -0,0 +1,11 @@
+import type { EntityMetadata } from '../typings';
+export interface IConfiguration {
+    get(key: string, defaultValue?: any): any;
+}
+export declare abstract class MetadataProvider {
+    protected readonly config: IConfiguration;
+    constructor(config: IConfiguration);
+    abstract loadEntityMetadata(meta: EntityMetadata, name: string): void;
+    loadFromCache(meta: EntityMetadata, cache: EntityMetadata): void;
+    useCache(): boolean;
+}

package/metadata/MetadataProvider.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataProvider = void 0;
+const Utils_1 = require("../utils/Utils");
+class MetadataProvider {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    loadFromCache(meta, cache) {
+        Object.values(cache.properties).forEach(prop => {
+            const metaProp = meta.properties[prop.name];
+            if (metaProp?.enum && Array.isArray(metaProp.items)) {
+                delete prop.items;
+            }
+        });
+        Utils_1.Utils.mergeConfig(meta, cache);
+    }
+    useCache() {
+        return this.config.get('metadataCache').enabled ?? false;
+    }
+}
+exports.MetadataProvider = MetadataProvider;

package/metadata/MetadataStorage.d.ts

@@ -0,0 +1,22 @@
+import { EntityMetadata, type Dictionary, type EntityData, type EntityName } from '../typings';
+import type { EntityManager } from '../EntityManager';
+export declare class MetadataStorage {
+    private static readonly metadata;
+    private readonly metadata;
+    constructor(metadata?: Dictionary<EntityMetadata>);
+    static getMetadata(): Dictionary<EntityMetadata>;
+    static getMetadata<T = any>(entity: string, path: string): EntityMetadata<T>;
+    static isKnownEntity(name: string): boolean;
+    static getMetadataFromDecorator<T = any>(target: T & Dictionary): EntityMetadata<T>;
+    static init(): MetadataStorage;
+    static clear(): void;
+    getAll(): Dictionary<EntityMetadata>;
+    getByDiscriminatorColumn<T>(meta: EntityMetadata<T>, data: EntityData<T>): EntityMetadata<T> | undefined;
+    get<T = any>(entityName: EntityName<T>, init?: boolean, validate?: boolean): EntityMetadata<T>;
+    find<T = any>(entityName: EntityName<T>): EntityMetadata<T> | undefined;
+    has(entity: string): boolean;
+    set(entity: string, meta: EntityMetadata): EntityMetadata;
+    reset(entity: string): void;
+    decorate(em: EntityManager): void;
+    [Symbol.iterator](): IterableIterator<EntityMetadata>;
+}

package/metadata/MetadataStorage.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataStorage = void 0;
+const typings_1 = require("../typings");
+const Utils_1 = require("../utils/Utils");
+const errors_1 = require("../errors");
+const EntityHelper_1 = require("../entity/EntityHelper");
+class MetadataStorage {
+    static metadata = Utils_1.Utils.getGlobalStorage('metadata');
+    metadata;
+    constructor(metadata = {}) {
+        this.metadata = Utils_1.Utils.copy(metadata, false);
+    }
+    static getMetadata(entity, path) {
+        const key = entity && path ? entity + '-' + Utils_1.Utils.hash(path) : null;
+        if (key && !MetadataStorage.metadata[key]) {
+            MetadataStorage.metadata[key] = new typings_1.EntityMetadata({ className: entity, path });
+        }
+        if (key) {
+            return MetadataStorage.metadata[key];
+        }
+        return MetadataStorage.metadata;
+    }
+    static isKnownEntity(name) {
+        return !!Object.values(this.metadata).find(meta => meta.className === name);
+    }
+    static getMetadataFromDecorator(target) {
+        const path = Utils_1.Utils.lookupPathFromDecorator(target.name);
+        const meta = MetadataStorage.getMetadata(target.name, path);
+        Object.defineProperty(target, '__path', { value: path, writable: true });
+        return meta;
+    }
+    static init() {
+        return new MetadataStorage(MetadataStorage.metadata);
+    }
+    static clear() {
+        Object.keys(this.metadata).forEach(k => delete this.metadata[k]);
+    }
+    getAll() {
+        return this.metadata;
+    }
+    getByDiscriminatorColumn(meta, data) {
+        const value = data[meta.root.discriminatorColumn];
+        if (!value) {
+            return undefined;
+        }
+        const type = meta.root.discriminatorMap[value];
+        return this.metadata[type];
+    }
+    get(entityName, init = false, validate = true) {
+        entityName = Utils_1.Utils.className(entityName);
+        if (validate && !init && !this.has(entityName)) {
+            throw errors_1.MetadataError.missingMetadata(entityName);
+        }
+        if (init && !this.has(entityName)) {
+            this.metadata[entityName] = new typings_1.EntityMetadata();
+        }
+        return this.metadata[entityName];
+    }
+    find(entityName) {
+        if (!entityName) {
+            return;
+        }
+        entityName = Utils_1.Utils.className(entityName);
+        return this.metadata[entityName];
+    }
+    has(entity) {
+        return entity in this.metadata;
+    }
+    set(entity, meta) {
+        return this.metadata[entity] = meta;
+    }
+    reset(entity) {
+        delete this.metadata[entity];
+    }
+    decorate(em) {
+        Object.values(this.metadata)
+            .filter(meta => meta.prototype)
+            .forEach(meta => EntityHelper_1.EntityHelper.decorate(meta, em));
+    }
+    *[Symbol.iterator]() {
+        for (const meta of Object.values(this.metadata)) {
+            yield meta;
+        }
+    }
+}
+exports.MetadataStorage = MetadataStorage;

package/metadata/MetadataValidator.d.ts

@@ -0,0 +1,24 @@
+import type { EntityMetadata } from '../typings';
+import { type MetadataDiscoveryOptions } from '../utils';
+import { ReferenceKind } from '../enums';
+import type { MetadataStorage } from './MetadataStorage';
+/**
+ * @internal
+ */
+export declare class MetadataValidator {
+    /**
+     * Validate there is only one property decorator. This disallows using `@Property()` together with e.g. `@ManyToOne()`
+     * on the same property. One should use only `@ManyToOne()` in such case.
+     * We allow the existence of the property in metadata if the reference type is the same, this should allow things like HMR to work.
+     */
+    static validateSingleDecorator(meta: EntityMetadata, propertyName: string, reference: ReferenceKind): void;
+    validateEntityDefinition<T>(metadata: MetadataStorage, name: string, options: MetadataDiscoveryOptions): void;
+    validateDiscovered(discovered: EntityMetadata[], options: MetadataDiscoveryOptions): void;
+    private validateReference;
+    private validateBidirectional;
+    private validateOwningSide;
+    private validateInverseSide;
+    private validateIndexes;
+    private validateDuplicateFieldNames;
+    private validateVersionField;
+}

package/metadata/MetadataValidator.js

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataValidator = void 0;
+const utils_1 = require("../utils");
+const errors_1 = require("../errors");
+const enums_1 = require("../enums");
+/**
+ * @internal
+ */
+class MetadataValidator {
+    /**
+     * Validate there is only one property decorator. This disallows using `@Property()` together with e.g. `@ManyToOne()`
+     * on the same property. One should use only `@ManyToOne()` in such case.
+     * We allow the existence of the property in metadata if the reference type is the same, this should allow things like HMR to work.
+     */
+    static validateSingleDecorator(meta, propertyName, reference) {
+        if (meta.properties[propertyName] && meta.properties[propertyName].kind !== reference) {
+            throw errors_1.MetadataError.multipleDecorators(meta.className, propertyName);
+        }
+    }
+    validateEntityDefinition(metadata, name, options) {
+        const meta = metadata.get(name);
+        if (meta.virtual || meta.expression) {
+            for (const prop of utils_1.Utils.values(meta.properties)) {
+                if (![enums_1.ReferenceKind.SCALAR, enums_1.ReferenceKind.EMBEDDED, enums_1.ReferenceKind.MANY_TO_ONE, enums_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind)) {
+                    throw new errors_1.MetadataError(`Only scalars, embedded properties and to-many relations are allowed inside virtual entity. Found '${prop.kind}' in ${meta.className}.${prop.name}`);
+                }
+                if (prop.primary) {
+                    throw new errors_1.MetadataError(`Virtual entity ${meta.className} cannot have primary key ${meta.className}.${prop.name}`);
+                }
+            }
+            return;
+        }
+        // entities have PK
+        if (!meta.embeddable && (!meta.primaryKeys || meta.primaryKeys.length === 0)) {
+            throw errors_1.MetadataError.fromMissingPrimaryKey(meta);
+        }
+        this.validateVersionField(meta);
+        this.validateDuplicateFieldNames(meta, options);
+        this.validateIndexes(meta, meta.indexes ?? [], 'index');
+        this.validateIndexes(meta, meta.uniques ?? [], 'unique');
+        for (const prop of utils_1.Utils.values(meta.properties)) {
+            if (prop.kind !== enums_1.ReferenceKind.SCALAR) {
+                this.validateReference(meta, prop, metadata);
+                this.validateBidirectional(meta, prop, metadata);
+            }
+            else if (metadata.has(prop.type)) {
+                throw errors_1.MetadataError.propertyTargetsEntityType(meta, prop, metadata.get(prop.type));
+            }
+        }
+    }
+    validateDiscovered(discovered, options) {
+        if (discovered.length === 0 && options.warnWhenNoEntities) {
+            throw errors_1.MetadataError.noEntityDiscovered();
+        }
+        const duplicates = utils_1.Utils.findDuplicates(discovered.map(meta => meta.className));
+        if (duplicates.length > 0 && options.checkDuplicateEntities) {
+            throw errors_1.MetadataError.duplicateEntityDiscovered(duplicates);
+        }
+        const tableNames = discovered.filter(meta => !meta.abstract && meta === meta.root && (meta.tableName || meta.collection) && meta.schema !== '*');
+        const duplicateTableNames = utils_1.Utils.findDuplicates(tableNames.map(meta => {
+            const tableName = meta.tableName || meta.collection;
+            return (meta.schema ? '.' + meta.schema : '') + tableName;
+        }));
+        if (duplicateTableNames.length > 0 && options.checkDuplicateTableNames && options.checkDuplicateEntities) {
+            throw errors_1.MetadataError.duplicateEntityDiscovered(duplicateTableNames, 'table names');
+        }
+        // validate we found at least one entity (not just abstract/base entities)
+        if (discovered.filter(meta => meta.name).length === 0 && options.warnWhenNoEntities) {
+            throw errors_1.MetadataError.onlyAbstractEntitiesDiscovered();
+        }
+        const unwrap = (type) => type
+            .replace(/Array<(.*)>/, '$1') // unwrap array
+            .replace(/\[]$/, '') // remove array suffix
+            .replace(/\((.*)\)/, '$1'); // unwrap union types
+        const name = (p) => {
+            if (typeof p === 'function') {
+                return utils_1.Utils.className(p());
+            }
+            return utils_1.Utils.className(p);
+        };
+        const pivotProps = new Map();
+        // check for not discovered entities
+        discovered.forEach(meta => Object.values(meta.properties).forEach(prop => {
+            if (prop.kind !== enums_1.ReferenceKind.SCALAR && !unwrap(prop.type).split(/ ?\| ?/).every(type => discovered.find(m => m.className === type))) {
+                throw errors_1.MetadataError.fromUnknownEntity(prop.type, `${meta.className}.${prop.name}`);
+            }
+            if (prop.pivotEntity) {
+                const props = pivotProps.get(name(prop.pivotEntity)) ?? [];
+                props.push({ meta, prop });
+                pivotProps.set(name(prop.pivotEntity), props);
+            }
+        }));
+        pivotProps.forEach(props => {
+            // if the pivot entity is used in more than one property, check if they are linked
+            if (props.length > 1 && props.every(p => !p.prop.mappedBy && !p.prop.inversedBy)) {
+                throw errors_1.MetadataError.invalidManyToManyWithPivotEntity(props[0].meta, props[0].prop, props[1].meta, props[1].prop);
+            }
+        });
+    }
+    validateReference(meta, prop, metadata) {
+        // references do have types
+        if (!prop.type) {
+            throw errors_1.MetadataError.fromWrongTypeDefinition(meta, prop);
+        }
+        // references do have type of known entity
+        if (!metadata.find(prop.type)) {
+            throw errors_1.MetadataError.fromWrongTypeDefinition(meta, prop);
+        }
+        if (metadata.find(prop.type).abstract && !metadata.find(prop.type).discriminatorColumn) {
+            throw errors_1.MetadataError.targetIsAbstract(meta, prop);
+        }
+    }
+    validateBidirectional(meta, prop, metadata) {
+        if (prop.inversedBy) {
+            const inverse = metadata.get(prop.type).properties[prop.inversedBy];
+            this.validateOwningSide(meta, prop, inverse, metadata);
+        }
+        else if (prop.mappedBy) {
+            const inverse = metadata.get(prop.type).properties[prop.mappedBy];
+            this.validateInverseSide(meta, prop, inverse, metadata);
+        }
+        else {
+            // 1:m property has `mappedBy`
+            if (prop.kind === enums_1.ReferenceKind.ONE_TO_MANY && !prop.mappedBy) {
+                throw errors_1.MetadataError.fromMissingOption(meta, prop, 'mappedBy');
+            }
+        }
+    }
+    validateOwningSide(meta, prop, inverse, metadata) {
+        // has correct `inversedBy` on owning side
+        if (!inverse) {
+            throw errors_1.MetadataError.fromWrongReference(meta, prop, 'inversedBy');
+        }
+        const targetClassName = metadata.find(inverse.type)?.root.className;
+        // has correct `inversedBy` reference type
+        if (inverse.type !== meta.className && targetClassName !== meta.root.className) {
+            throw errors_1.MetadataError.fromWrongReference(meta, prop, 'inversedBy', inverse);
+        }
+        // inverse side is not defined as owner
+        if (inverse.inversedBy || inverse.owner) {
+            throw errors_1.MetadataError.fromWrongOwnership(meta, prop, 'inversedBy');
+        }
+    }
+    validateInverseSide(meta, prop, owner, metadata) {
+        // has correct `mappedBy` on inverse side
+        if (prop.mappedBy && !owner) {
+            throw errors_1.MetadataError.fromWrongReference(meta, prop, 'mappedBy');
+        }
+        // has correct `mappedBy` reference type
+        if (owner.type !== meta.className && metadata.find(owner.type)?.root.className !== meta.root.className) {
+            throw errors_1.MetadataError.fromWrongReference(meta, prop, 'mappedBy', owner);
+        }
+        // owning side is not defined as inverse
+        if (owner.mappedBy) {
+            throw errors_1.MetadataError.fromWrongOwnership(meta, prop, 'mappedBy');
+        }
+        // owning side is not defined as inverse
+        const valid = [
+            { owner: enums_1.ReferenceKind.MANY_TO_ONE, inverse: enums_1.ReferenceKind.ONE_TO_MANY },
+            { owner: enums_1.ReferenceKind.MANY_TO_MANY, inverse: enums_1.ReferenceKind.MANY_TO_MANY },
+            { owner: enums_1.ReferenceKind.ONE_TO_ONE, inverse: enums_1.ReferenceKind.ONE_TO_ONE },
+        ];
+        if (!valid.find(spec => spec.owner === owner.kind && spec.inverse === prop.kind)) {
+            throw errors_1.MetadataError.fromWrongReferenceKind(meta, owner, prop);
+        }
+        if (prop.primary) {
+            throw errors_1.MetadataError.fromInversideSidePrimary(meta, owner, prop);
+        }
+    }
+    validateIndexes(meta, indexes, type) {
+        const root = meta.getStiRoot();
+        for (const index of indexes) {
+            for (const propName of utils_1.Utils.asArray(index.properties)) {
+                const prop = root.properties[propName];
+                if (!prop && !Object.values(meta.root.properties).some(p => propName.startsWith(p.name + '.'))) {
+                    throw errors_1.MetadataError.unknownIndexProperty(meta, propName, type);
+                }
+            }
+        }
+    }
+    validateDuplicateFieldNames(meta, options) {
+        const candidates = Object.values(meta.properties)
+            .filter(prop => prop.persist !== false && !prop.inherited && prop.fieldNames?.length === 1 && (prop.kind !== enums_1.ReferenceKind.EMBEDDED || prop.object))
+            .map(prop => prop.fieldNames[0]);
+        const duplicates = utils_1.Utils.findDuplicates(candidates);
+        if (duplicates.length > 0 && options.checkDuplicateFieldNames) {
+            const pairs = duplicates.flatMap(name => {
+                return Object.values(meta.properties)
+                    .filter(p => p.fieldNames?.[0] === name)
+                    .map(prop => {
+                    return [prop.embedded ? prop.embedded.join('.') : prop.name, prop.fieldNames[0]];
+                });
+            });
+            throw errors_1.MetadataError.duplicateFieldName(meta.className, pairs);
+        }
+    }
+    validateVersionField(meta) {
+        if (!meta.versionProperty) {
+            return;
+        }
+        const props = Object.values(meta.properties).filter(p => p.version);
+        if (props.length > 1) {
+            throw errors_1.MetadataError.multipleVersionFields(meta, props.map(p => p.name));
+        }
+        const prop = meta.properties[meta.versionProperty];
+        const type = prop.runtimeType ?? prop.columnTypes?.[0] ?? prop.type;
+        if (type !== 'number' && type !== 'Date' && !type.startsWith('timestamp') && !type.startsWith('datetime')) {
+            throw errors_1.MetadataError.invalidVersionFieldType(meta);
+        }
+    }
+}
+exports.MetadataValidator = MetadataValidator;

package/metadata/ReflectMetadataProvider.d.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata';
+import type { EntityMetadata, EntityProperty } from '../typings';
+import { MetadataProvider } from './MetadataProvider';
+export declare class ReflectMetadataProvider extends MetadataProvider {
+    loadEntityMetadata(meta: EntityMetadata, name: string): void;
+    protected initProperties(meta: EntityMetadata): void;
+    protected initPropertyType(meta: EntityMetadata, prop: EntityProperty): void;
+}

package/metadata/ReflectMetadataProvider.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReflectMetadataProvider = void 0;
+require("reflect-metadata");
+const MetadataProvider_1 = require("./MetadataProvider");
+const enums_1 = require("../enums");
+const Utils_1 = require("../utils/Utils");
+class ReflectMetadataProvider extends MetadataProvider_1.MetadataProvider {
+    loadEntityMetadata(meta, name) {
+        this.initProperties(meta);
+    }
+    initProperties(meta) {
+        // load types and column names
+        for (const prop of Object.values(meta.properties)) {
+            if (Utils_1.Utils.isString(prop.entity)) {
+                prop.type = prop.entity;
+            }
+            else if (prop.entity) {
+                const tmp = prop.entity();
+                prop.type = Array.isArray(tmp) ? tmp.map(t => Utils_1.Utils.className(t)).sort().join(' | ') : Utils_1.Utils.className(tmp);
+            }
+            else {
+                this.initPropertyType(meta, prop);
+            }
+        }
+    }
+    initPropertyType(meta, prop) {
+        const type = Reflect.getMetadata('design:type', meta.prototype, prop.name);
+        if (!prop.type && (!type || (type === Object && prop.kind !== enums_1.ReferenceKind.SCALAR))) {
+            throw new Error(`Please provide either 'type' or 'entity' attribute in ${meta.className}.${prop.name}. If you are using decorators, ensure you have 'emitDecoratorMetadata' enabled in your tsconfig.json.`);
+        }
+        // Force mapping to UnknownType which is a string when we see just `Object`, as that often means failed inference.
+        // This is to prevent defaulting to JSON column type, which can be often hard to revert and cause hard to understand issues with PKs.
+        // If there are explicitly provided `columnTypes`, we use those instead for the inference, this way
+        // we can have things like `columnType: 'timestamp'` be respected as `type: 'Date'`.
+        if (prop.kind === enums_1.ReferenceKind.SCALAR && type === Object && !prop.columnTypes) {
+            prop.type ??= 'any';
+            return;
+        }
+        let typeName = type?.name;
+        if (typeName && ['string', 'number', 'boolean', 'array', 'object'].includes(typeName.toLowerCase())) {
+            typeName = typeName.toLowerCase();
+        }
+        prop.type ??= typeName;
+        prop.runtimeType = typeName;
+    }
+}
+exports.ReflectMetadataProvider = ReflectMetadataProvider;

package/metadata/index.d.ts

@@ -0,0 +1,6 @@
+export * from './EntitySchema';
+export * from './MetadataDiscovery';
+export * from './MetadataStorage';
+export * from './MetadataProvider';
+export * from './MetadataValidator';
+export * from './ReflectMetadataProvider';

package/metadata/index.js

@@ -0,0 +1,22 @@
+"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("./EntitySchema"), exports);
+__exportStar(require("./MetadataDiscovery"), exports);
+__exportStar(require("./MetadataStorage"), exports);
+__exportStar(require("./MetadataProvider"), exports);
+__exportStar(require("./MetadataValidator"), exports);
+__exportStar(require("./ReflectMetadataProvider"), exports);

package/naming-strategy/AbstractNamingStrategy.d.ts

@@ -0,0 +1,18 @@
+import type { NamingStrategy } from './NamingStrategy';
+export declare abstract class AbstractNamingStrategy implements NamingStrategy {
+    getClassName(file: string, separator?: string): string;
+    classToMigrationName(timestamp: string, customMigrationName?: string): string;
+    indexName(tableName: string, columns: string[], type: 'primary' | 'foreign' | 'unique' | 'index' | 'sequence' | 'check'): string;
+    /**
+     * @inheritDoc
+     */
+    getEntityName(tableName: string, schemaName?: string): string;
+    columnNameToProperty(columnName: string): string;
+    aliasName(entityName: string, index: number): string;
+    abstract classToTableName(entityName: string): string;
+    abstract joinColumnName(propertyName: string): string;
+    abstract joinKeyColumnName(entityName: string, referencedColumnName?: string): string;
+    abstract joinTableName(sourceEntity: string, targetEntity: string, propertyName?: string): string;
+    abstract propertyToColumnName(propertyName: string, object?: boolean): string;
+    abstract referenceColumnName(): string;
+}

package/naming-strategy/AbstractNamingStrategy.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractNamingStrategy = void 0;
+class AbstractNamingStrategy {
+    getClassName(file, separator = '-') {
+        const name = file.split('.')[0];
+        const ret = name.replace(new RegExp(`${separator}+(\\w)`, 'g'), m => m[1].toUpperCase());
+        return ret.charAt(0).toUpperCase() + ret.slice(1);
+    }
+    classToMigrationName(timestamp, customMigrationName) {
+        let migrationName = `Migration${timestamp}`;
+        if (customMigrationName) {
+            migrationName += `_${customMigrationName}`;
+        }
+        return migrationName;
+    }
+    indexName(tableName, columns, type) {
+        /* istanbul ignore next */
+        if (tableName.includes('.')) {
+            tableName = tableName.substring(tableName.indexOf('.') + 1);
+        }
+        if (type === 'primary') {
+            return `${tableName}_pkey`;
+        }
+        columns = columns.map(col => col.replace(/\./g, '_'));
+        if (type === 'sequence') {
+            return `${tableName}_${columns.join('_')}_seq`;
+        }
+        if (columns.length > 0) {
+            return `${tableName}_${columns.join('_')}_${type}`;
+        }
+        return `${tableName}_${type}`;
+    }
+    /**
+     * @inheritDoc
+     */
+    getEntityName(tableName, schemaName) {
+        return this.getClassName(tableName, '_');
+    }
+    columnNameToProperty(columnName) {
+        return columnName.replace(/[_\- ](\w)/g, m => m[1].toUpperCase()).replace(/[_\- ]+/g, '');
+    }
+    aliasName(entityName, index) {
+        // Take only the first letter of the prefix to keep character counts down since some engines have character limits
+        return entityName.charAt(0).toLowerCase() + index;
+    }
+}
+exports.AbstractNamingStrategy = AbstractNamingStrategy;

package/naming-strategy/EntityCaseNamingStrategy.d.ts

@@ -0,0 +1,12 @@
+import { AbstractNamingStrategy } from './AbstractNamingStrategy';
+/**
+ * This strategy keeps original entity/property names for table/column.
+ */
+export declare class EntityCaseNamingStrategy extends AbstractNamingStrategy {
+    classToTableName(entityName: string): string;
+    joinColumnName(propertyName: string): string;
+    joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean): string;
+    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string): string;
+    propertyToColumnName(propertyName: string): string;
+    referenceColumnName(): string;
+}

package/naming-strategy/EntityCaseNamingStrategy.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityCaseNamingStrategy = void 0;
+const AbstractNamingStrategy_1 = require("./AbstractNamingStrategy");
+/**
+ * This strategy keeps original entity/property names for table/column.
+ */
+class EntityCaseNamingStrategy extends AbstractNamingStrategy_1.AbstractNamingStrategy {
+    classToTableName(entityName) {
+        return entityName;
+    }
+    joinColumnName(propertyName) {
+        return propertyName;
+    }
+    joinKeyColumnName(entityName, referencedColumnName, composite = false) {
+        const name = entityName.substr(0, 1).toLowerCase() + entityName.substr(1);
+        if (composite && referencedColumnName) {
+            return name + '_' + referencedColumnName;
+        }
+        return name;
+    }
+    joinTableName(sourceEntity, targetEntity, propertyName) {
+        return this.classToTableName(sourceEntity) + '_' + this.propertyToColumnName(propertyName);
+    }
+    propertyToColumnName(propertyName) {
+        return propertyName;
+    }
+    referenceColumnName() {
+        return 'id';
+    }
+}
+exports.EntityCaseNamingStrategy = EntityCaseNamingStrategy;

package/naming-strategy/MongoNamingStrategy.d.ts

@@ -0,0 +1,9 @@
+import { AbstractNamingStrategy } from './AbstractNamingStrategy';
+export declare class MongoNamingStrategy extends AbstractNamingStrategy {
+    classToTableName(entityName: string): string;
+    joinColumnName(propertyName: string): string;
+    joinKeyColumnName(entityName: string, referencedColumnName?: string): string;
+    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string): string;
+    propertyToColumnName(propertyName: string): string;
+    referenceColumnName(): string;
+}

package/naming-strategy/MongoNamingStrategy.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoNamingStrategy = void 0;
+const AbstractNamingStrategy_1 = require("./AbstractNamingStrategy");
+class MongoNamingStrategy extends AbstractNamingStrategy_1.AbstractNamingStrategy {
+    classToTableName(entityName) {
+        return entityName.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+    }
+    joinColumnName(propertyName) {
+        return propertyName;
+    }
+    joinKeyColumnName(entityName, referencedColumnName) {
+        return entityName;
+    }
+    joinTableName(sourceEntity, targetEntity, propertyName) {
+        return this.classToTableName(sourceEntity) + '_' + this.propertyToColumnName(propertyName);
+    }
+    propertyToColumnName(propertyName) {
+        return propertyName;
+    }
+    referenceColumnName() {
+        return '_id';
+    }
+}
+exports.MongoNamingStrategy = MongoNamingStrategy;