@mikro-orm/sql 7.0.0-dev.97 → 7.0.0-dev.98

package/query/ScalarCriteriaNode.d.ts

@@ -0,0 +1,10 @@
+import { CriteriaNode } from './CriteriaNode.js';
+import type { ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings.js';
+/**
+ * @internal
+ */
+export declare class ScalarCriteriaNode<T extends object> extends CriteriaNode<T> {
+    process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
+    willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
+    private shouldJoin;
+}

package/query/ScalarCriteriaNode.js

@@ -0,0 +1,49 @@
+import { ARRAY_OPERATORS, ReferenceKind } from '@mikro-orm/core';
+import { CriteriaNode } from './CriteriaNode.js';
+import { JoinType, QueryType } from './enums.js';
+import { QueryBuilder } from './QueryBuilder.js';
+/**
+ * @internal
+ */
+export class ScalarCriteriaNode extends CriteriaNode {
+    process(qb, options) {
+        const matchPopulateJoins = options?.matchPopulateJoins || (this.prop && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind));
+        const nestedAlias = qb.getAliasForJoinPath(this.getPath(), { ...options, matchPopulateJoins });
+        if (this.shouldJoin(qb, nestedAlias)) {
+            const path = this.getPath();
+            const parentPath = this.parent.getPath(); // the parent is always there, otherwise `shouldJoin` would return `false`
+            const nestedAlias = qb.getAliasForJoinPath(path) || qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
+            const field = this.aliased(this.prop.name, options?.alias);
+            const type = this.prop.kind === ReferenceKind.MANY_TO_MANY ? JoinType.pivotJoin : JoinType.leftJoin;
+            qb.join(field, nestedAlias, undefined, type, path);
+            // select the owner as virtual property when joining from 1:1 inverse side, but only if the parent is root entity
+            if (this.prop.kind === ReferenceKind.ONE_TO_ONE && !parentPath.includes('.') && !qb._fields?.includes(field)) {
+                qb.addSelect(field);
+            }
+        }
+        if (this.payload instanceof QueryBuilder) {
+            return this.payload.getNativeQuery().toRaw();
+        }
+        if (this.payload && typeof this.payload === 'object') {
+            const keys = Object.keys(this.payload).filter(key => ARRAY_OPERATORS.includes(key) && Array.isArray(this.payload[key]));
+            for (const key of keys) {
+                this.payload[key] = JSON.stringify(this.payload[key]);
+            }
+        }
+        return this.payload;
+    }
+    willAutoJoin(qb, alias, options) {
+        return this.shouldJoin(qb, alias);
+    }
+    shouldJoin(qb, nestedAlias) {
+        if (!this.parent || !this.prop || (nestedAlias && [QueryType.SELECT, QueryType.COUNT].includes(qb.type ?? QueryType.SELECT))) {
+            return false;
+        }
+        switch (this.prop.kind) {
+            case ReferenceKind.ONE_TO_MANY: return true;
+            case ReferenceKind.MANY_TO_MANY: return true;
+            case ReferenceKind.ONE_TO_ONE: return !this.prop.owner;
+            default: return false; // SCALAR, MANY_TO_ONE
+        }
+    }
+}

package/query/enums.d.ts

@@ -0,0 +1,18 @@
+export declare enum QueryType {
+    TRUNCATE = "TRUNCATE",
+    SELECT = "SELECT",
+    COUNT = "COUNT",
+    INSERT = "INSERT",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE",
+    UPSERT = "UPSERT"
+}
+export declare enum JoinType {
+    leftJoin = "left join",
+    innerJoin = "inner join",
+    nestedLeftJoin = "nested left join",
+    nestedInnerJoin = "nested inner join",
+    pivotJoin = "pivot join",
+    innerJoinLateral = "inner join lateral",
+    leftJoinLateral = "left join lateral"
+}

package/query/enums.js

@@ -0,0 +1,20 @@
+export var QueryType;
+(function (QueryType) {
+    QueryType["TRUNCATE"] = "TRUNCATE";
+    QueryType["SELECT"] = "SELECT";
+    QueryType["COUNT"] = "COUNT";
+    QueryType["INSERT"] = "INSERT";
+    QueryType["UPDATE"] = "UPDATE";
+    QueryType["DELETE"] = "DELETE";
+    QueryType["UPSERT"] = "UPSERT";
+})(QueryType || (QueryType = {}));
+export var JoinType;
+(function (JoinType) {
+    JoinType["leftJoin"] = "left join";
+    JoinType["innerJoin"] = "inner join";
+    JoinType["nestedLeftJoin"] = "nested left join";
+    JoinType["nestedInnerJoin"] = "nested inner join";
+    JoinType["pivotJoin"] = "pivot join";
+    JoinType["innerJoinLateral"] = "inner join lateral";
+    JoinType["leftJoinLateral"] = "left join lateral";
+})(JoinType || (JoinType = {}));

package/query/index.d.ts

@@ -0,0 +1,10 @@
+export * from './enums.js';
+export * from './QueryBuilderHelper.js';
+export * from './QueryBuilder.js';
+export * from './CriteriaNode.js';
+export * from './ArrayCriteriaNode.js';
+export * from './ObjectCriteriaNode.js';
+export * from './ScalarCriteriaNode.js';
+export * from './CriteriaNodeFactory.js';
+export * from './NativeQueryBuilder.js';
+export * from './raw.js';

package/query/index.js

@@ -0,0 +1,10 @@
+export * from './enums.js';
+export * from './QueryBuilderHelper.js';
+export * from './QueryBuilder.js';
+export * from './CriteriaNode.js';
+export * from './ArrayCriteriaNode.js';
+export * from './ObjectCriteriaNode.js';
+export * from './ScalarCriteriaNode.js';
+export * from './CriteriaNodeFactory.js';
+export * from './NativeQueryBuilder.js';
+export * from './raw.js';

package/query/raw.d.ts

@@ -0,0 +1,59 @@
+import { type AnyString, type Dictionary, type EntityKey, type RawQueryFragment } from '@mikro-orm/core';
+import type { SelectQueryBuilder } from 'kysely';
+import { QueryBuilder } from './QueryBuilder.js';
+/**
+ * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
+ * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
+ * and key. When serialized, the fragment key gets cached and only such cached key will be recognized by the ORM.
+ * This adds a runtime safety to the raw query fragments.
+ *
+ * > **`raw()` helper is required since v6 to use a raw fragment in your query, both through EntityManager and QueryBuilder.**
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: raw('now()') });
+ *
+ * // as a key
+ * await em.find(User, { [raw('lower(name)')]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [raw('(select 1 = 1)')]: [] });
+ * ```
+ *
+ * The `raw` helper supports several signatures, you can pass in a callback that receives the current property alias:
+ *
+ * ```ts
+ * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
+ * ```
+ *
+ * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
+ *
+ * ```ts
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ * ```
+ *
+ * When using inside filters, you might have to use a callback signature to create new raw instance for every filter usage.
+ *
+ * ```ts
+ * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
+ * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export declare function raw<T extends object = any, R = any>(sql: SelectQueryBuilder<any, any, any> | QueryBuilder<T> | EntityKey<T> | EntityKey<T>[] | AnyString | ((alias: string) => string) | RawQueryFragment, params?: readonly unknown[] | Dictionary<unknown>): NoInfer<R>;

package/query/raw.js

@@ -0,0 +1,68 @@
+import { raw as raw_, Utils } from '@mikro-orm/core';
+import { QueryBuilder } from './QueryBuilder.js';
+/**
+ * Creates raw SQL query fragment that can be assigned to a property or part of a filter. This fragment is represented
+ * by `RawQueryFragment` class instance that can be serialized to a string, so it can be used both as an object value
+ * and key. When serialized, the fragment key gets cached and only such cached key will be recognized by the ORM.
+ * This adds a runtime safety to the raw query fragments.
+ *
+ * > **`raw()` helper is required since v6 to use a raw fragment in your query, both through EntityManager and QueryBuilder.**
+ *
+ * ```ts
+ * // as a value
+ * await em.find(User, { time: raw('now()') });
+ *
+ * // as a key
+ * await em.find(User, { [raw('lower(name)')]: name.toLowerCase() });
+ *
+ * // value can be empty array
+ * await em.find(User, { [raw('(select 1 = 1)')]: [] });
+ * ```
+ *
+ * The `raw` helper supports several signatures, you can pass in a callback that receives the current property alias:
+ *
+ * ```ts
+ * await em.find(User, { [raw(alias => `lower(${alias}.name)`)]: name.toLowerCase() });
+ * ```
+ *
+ * You can also use the `sql` tagged template function, which works the same, but supports only the simple string signature:
+ *
+ * ```ts
+ * await em.find(User, { [sql`lower(name)`]: name.toLowerCase() });
+ * ```
+ *
+ * When using inside filters, you might have to use a callback signature to create new raw instance for every filter usage.
+ *
+ * ```ts
+ * @Filter({ name: 'long', cond: () => ({ [raw('length(perex)')]: { $gt: 10000 } }) })
+ * ```
+ *
+ * The `raw` helper can be used within indexes and uniques to write database-agnostic SQL expressions. In that case, you can use `'??'` to tag your database identifiers (table name, column names, index name, ...) inside your expression, and pass those identifiers as a second parameter to the `raw` helper. Internally, those will automatically be quoted according to the database in use:
+ *
+ * ```ts
+ * // On postgres, will produce: create index "index custom_idx_on_name" on "library.author" ("country")
+ * // On mysql, will produce: create index `index custom_idx_on_name` on `library.author` (`country`)
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => raw(`create index ?? on ?? (??)`, ['custom_idx_on_name', table, columns.name]) })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ *
+ * You can also use the `quote` tag function to write database-agnostic SQL expressions. The end-result is the same as using the `raw` function regarding database identifiers quoting, only to have a more elegant expression syntax:
+ *
+ * ```ts
+ * @Index({ name: 'custom_idx_on_name', expression: (table, columns) => quote`create index ${'custom_idx_on_name'} on ${table} (${columns.name})` })
+ * @Entity({ schema: 'library' })
+ * export class Author { ... }
+ * ```
+ */
+export function raw(sql, params) {
+    if (Utils.isObject(sql) && 'compile' in sql) {
+        const query = sql.compile();
+        return raw_(query.sql, query.parameters);
+    }
+    if (sql instanceof QueryBuilder) {
+        const query = sql.toQuery();
+        return raw_(query.sql, query.params);
+    }
+    return raw_(sql, params);
+}

package/schema/DatabaseSchema.d.ts

@@ -0,0 +1,45 @@
+import { type Configuration, type Dictionary, type EntityMetadata } from '@mikro-orm/core';
+import { DatabaseTable } from './DatabaseTable.js';
+import type { AbstractSqlConnection } from '../AbstractSqlConnection.js';
+import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
+/**
+ * @internal
+ */
+export declare class DatabaseSchema {
+    private readonly platform;
+    readonly name: string;
+    private tables;
+    private namespaces;
+    private nativeEnums;
+    constructor(platform: AbstractSqlPlatform, name: string);
+    addTable(name: string, schema: string | undefined | null, comment?: string): DatabaseTable;
+    getTables(): DatabaseTable[];
+    getTable(name: string): DatabaseTable | undefined;
+    hasTable(name: string): boolean;
+    setNativeEnums(nativeEnums: Dictionary<{
+        name: string;
+        schema?: string;
+        items: string[];
+    }>): void;
+    getNativeEnums(): Dictionary<{
+        name: string;
+        schema?: string;
+        items: string[];
+    }>;
+    getNativeEnum(name: string): {
+        name: string;
+        schema?: string;
+        items: string[];
+    };
+    hasNamespace(namespace: string): boolean;
+    hasNativeEnum(name: string): boolean;
+    getNamespaces(): string[];
+    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[], takeTables?: (string | RegExp)[], skipTables?: (string | RegExp)[]): Promise<DatabaseSchema>;
+    static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string): DatabaseSchema;
+    private static getSchemaName;
+    private static matchName;
+    private static isTableNameAllowed;
+    private static shouldHaveColumn;
+    toJSON(): Dictionary;
+    prune(schema: string | undefined, wildcardSchemaTables: string[]): void;
+}

package/schema/DatabaseSchema.js

@@ -0,0 +1,185 @@
+import { ReferenceKind, RawQueryFragment, } from '@mikro-orm/core';
+import { DatabaseTable } from './DatabaseTable.js';
+/**
+ * @internal
+ */
+export class DatabaseSchema {
+    platform;
+    name;
+    tables = [];
+    namespaces = new Set();
+    nativeEnums = {}; // for postgres
+    constructor(platform, name) {
+        this.platform = platform;
+        this.name = name;
+    }
+    addTable(name, schema, comment) {
+        const namespaceName = schema ?? this.name;
+        const table = new DatabaseTable(this.platform, name, namespaceName);
+        table.nativeEnums = this.nativeEnums;
+        table.comment = comment;
+        this.tables.push(table);
+        if (namespaceName != null) {
+            this.namespaces.add(namespaceName);
+        }
+        return table;
+    }
+    getTables() {
+        return this.tables;
+    }
+    getTable(name) {
+        return this.tables.find(t => t.name === name || `${t.schema}.${t.name}` === name);
+    }
+    hasTable(name) {
+        return !!this.getTable(name);
+    }
+    setNativeEnums(nativeEnums) {
+        this.nativeEnums = nativeEnums;
+        for (const nativeEnum of Object.values(nativeEnums)) {
+            if (nativeEnum.schema && nativeEnum.schema !== '*') {
+                this.namespaces.add(nativeEnum.schema);
+            }
+        }
+    }
+    getNativeEnums() {
+        return this.nativeEnums;
+    }
+    getNativeEnum(name) {
+        return this.nativeEnums[name];
+    }
+    hasNamespace(namespace) {
+        return this.namespaces.has(namespace);
+    }
+    hasNativeEnum(name) {
+        return name in this.nativeEnums;
+    }
+    getNamespaces() {
+        return [...this.namespaces];
+    }
+    static async create(connection, platform, config, schemaName, schemas, takeTables, skipTables) {
+        const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema') ?? platform.getDefaultSchemaName());
+        const allTables = await connection.execute(platform.getSchemaHelper().getListTablesSQL());
+        const parts = config.get('migrations').tableName.split('.');
+        const migrationsTableName = parts[1] ?? parts[0];
+        const migrationsSchemaName = parts.length > 1 ? parts[0] : config.get('schema', platform.getDefaultSchemaName());
+        const tables = allTables.filter(t => this.isTableNameAllowed(t.table_name, takeTables, skipTables) && (t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName)));
+        await platform.getSchemaHelper().loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined);
+        return schema;
+    }
+    static fromMetadata(metadata, platform, config, schemaName) {
+        const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema'));
+        const nativeEnums = {};
+        const skipColumns = config.get('schemaGenerator').skipColumns || {};
+        for (const meta of metadata) {
+            for (const prop of meta.props) {
+                if (prop.nativeEnumName) {
+                    let key = prop.nativeEnumName;
+                    let enumName = prop.nativeEnumName;
+                    let enumSchema = meta.schema ?? schema.name;
+                    if (key.includes('.')) {
+                        const [explicitSchema, ...parts] = prop.nativeEnumName.split('.');
+                        enumName = parts.join('.');
+                        key = enumName;
+                        enumSchema = explicitSchema;
+                    }
+                    if (enumSchema && enumSchema !== '*' && enumSchema !== platform.getDefaultSchemaName()) {
+                        key = enumSchema + '.' + key;
+                    }
+                    nativeEnums[key] = {
+                        name: enumName,
+                        schema: enumSchema,
+                        items: prop.items?.map(val => '' + val) ?? [],
+                    };
+                }
+            }
+        }
+        schema.setNativeEnums(nativeEnums);
+        for (const meta of metadata) {
+            const table = schema.addTable(meta.collection, this.getSchemaName(meta, config, schemaName));
+            table.comment = meta.comment;
+            for (const prop of meta.props) {
+                if (!this.shouldHaveColumn(meta, prop, skipColumns)) {
+                    continue;
+                }
+                table.addColumnFromProperty(prop, meta, config);
+            }
+            meta.indexes.forEach(index => table.addIndex(meta, index, 'index'));
+            meta.uniques.forEach(index => table.addIndex(meta, index, 'unique'));
+            table.addIndex(meta, { properties: meta.props.filter(prop => prop.primary).map(prop => prop.name) }, 'primary');
+            for (const check of meta.checks) {
+                const columnName = check.property ? meta.properties[check.property].fieldNames[0] : undefined;
+                let expression = check.expression;
+                const raw = RawQueryFragment.getKnownFragment(expression);
+                if (raw) {
+                    expression = platform.formatQuery(raw.sql, raw.params);
+                }
+                table.addCheck({
+                    name: check.name,
+                    expression,
+                    definition: `check (${check.expression})`,
+                    columnName,
+                });
+            }
+        }
+        return schema;
+    }
+    static getSchemaName(meta, config, schema) {
+        return (meta.schema === '*' ? schema : meta.schema) ?? config.get('schema');
+    }
+    static matchName(name, nameToMatch) {
+        return typeof nameToMatch === 'string'
+            ? name.toLocaleLowerCase() === nameToMatch.toLocaleLowerCase()
+            : nameToMatch.test(name);
+    }
+    static isTableNameAllowed(tableName, takeTables, skipTables) {
+        return ((takeTables?.some(tableNameToMatch => this.matchName(tableName, tableNameToMatch)) ?? true) &&
+            !(skipTables?.some(tableNameToMatch => this.matchName(tableName, tableNameToMatch)) ?? false));
+    }
+    static shouldHaveColumn(meta, prop, skipColumns) {
+        if (prop.persist === false || (prop.columnTypes?.length ?? 0) === 0) {
+            return false;
+        }
+        // Check if column should be skipped
+        if (skipColumns) {
+            const tableName = meta.tableName;
+            const tableSchema = meta.schema;
+            const fullTableName = tableSchema ? `${tableSchema}.${tableName}` : tableName;
+            // Check for skipColumns by table name or fully qualified table name
+            const columnsToSkip = skipColumns[tableName] || skipColumns[fullTableName];
+            if (columnsToSkip) {
+                for (const fieldName of prop.fieldNames) {
+                    if (columnsToSkip.some(pattern => this.matchName(fieldName, pattern))) {
+                        return false;
+                    }
+                }
+            }
+        }
+        if (prop.kind === ReferenceKind.EMBEDDED && prop.object) {
+            return true;
+        }
+        const getRootProperty = (prop) => prop.embedded ? getRootProperty(meta.properties[prop.embedded[0]]) : prop;
+        const rootProp = getRootProperty(prop);
+        if (rootProp.kind === ReferenceKind.EMBEDDED) {
+            return prop === rootProp || !rootProp.object;
+        }
+        return [ReferenceKind.SCALAR, ReferenceKind.MANY_TO_ONE].includes(prop.kind) || (prop.kind === ReferenceKind.ONE_TO_ONE && prop.owner);
+    }
+    toJSON() {
+        const { platform, namespaces, ...rest } = this;
+        return { namespaces: [...namespaces], ...rest };
+    }
+    prune(schema, wildcardSchemaTables) {
+        const hasWildcardSchema = wildcardSchemaTables.length > 0;
+        this.tables = this.tables.filter(table => {
+            return (!schema && !hasWildcardSchema) // no schema specified and we don't have any multi-schema entity
+                || table.schema === schema // specified schema matches the table's one
+                || (!schema && !wildcardSchemaTables.includes(table.name)); // no schema specified and the table has fixed one provided
+        });
+        // remove namespaces of ignored tables
+        for (const ns of this.namespaces) {
+            if (!this.tables.some(t => t.schema === ns) && !Object.values(this.nativeEnums).some(e => e.schema === ns)) {
+                this.namespaces.delete(ns);
+            }
+        }
+    }
+}

package/schema/DatabaseTable.d.ts

@@ -0,0 +1,68 @@
+import { type Configuration, type DeferMode, type Dictionary, type EntityMetadata, type EntityProperty, type IndexCallback, type NamingStrategy } from '@mikro-orm/core';
+import type { SchemaHelper } from './SchemaHelper.js';
+import type { CheckDef, Column, ForeignKey, IndexDef } from '../typings.js';
+import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
+/**
+ * @internal
+ */
+export declare class DatabaseTable {
+    private readonly platform;
+    readonly name: string;
+    readonly schema?: string | undefined;
+    private columns;
+    private indexes;
+    private checks;
+    private foreignKeys;
+    nativeEnums: Dictionary<{
+        name: string;
+        schema?: string;
+        items: string[];
+    }>;
+    comment?: string;
+    constructor(platform: AbstractSqlPlatform, name: string, schema?: string | undefined);
+    getQuotedName(): string;
+    getColumns(): Column[];
+    getColumn(name: string): Column | undefined;
+    removeColumn(name: string): void;
+    getIndexes(): IndexDef[];
+    getChecks(): CheckDef[];
+    init(cols: Column[], indexes: IndexDef[] | undefined, checks: CheckDef[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;
+    addColumn(column: Column): void;
+    addColumnFromProperty(prop: EntityProperty, meta: EntityMetadata, config: Configuration): void;
+    private getIndexName;
+    getEntityDeclaration(namingStrategy: NamingStrategy, schemaHelper: SchemaHelper, scalarPropertiesForRelations: 'always' | 'never' | 'smart'): EntityMetadata;
+    private foreignKeysToProps;
+    private findFkIndex;
+    private getIndexProperties;
+    private getSafeBaseNameForFkProp;
+    /**
+     * The shortest name is stripped of the default namespace. All other namespaced elements are returned as full-qualified names.
+     */
+    getShortestName(skipDefaultSchema?: boolean): string;
+    getForeignKeys(): Dictionary<ForeignKey>;
+    hasColumn(columnName: string): boolean;
+    getIndex(indexName: string): IndexDef | undefined;
+    hasIndex(indexName: string): boolean;
+    getCheck(checkName: string): CheckDef<unknown> | undefined;
+    hasCheck(checkName: string): boolean;
+    getPrimaryKey(): IndexDef | undefined;
+    hasPrimaryKey(): boolean;
+    private getForeignKeyDeclaration;
+    private getPropertyDeclaration;
+    private getReferenceKind;
+    private getPropertyName;
+    private getPropertyTypeForForeignKey;
+    private getPropertyTypeForColumn;
+    private getPropertyDefaultValue;
+    private processIndexExpression;
+    addIndex(meta: EntityMetadata, index: {
+        properties?: string | string[];
+        name?: string;
+        type?: string;
+        expression?: string | IndexCallback<any>;
+        deferMode?: DeferMode | `${DeferMode}`;
+        options?: Dictionary;
+    }, type: 'index' | 'unique' | 'primary'): void;
+    addCheck(check: CheckDef): void;
+    toJSON(): Dictionary;
+}