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

package/drivers/DatabaseDriver.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseDriver = void 0;
+const IDatabaseDriver_1 = require("./IDatabaseDriver");
+const utils_1 = require("../utils");
+const enums_1 = require("../enums");
+const EntityManager_1 = require("../EntityManager");
+const errors_1 = require("../errors");
+const exceptions_1 = require("../exceptions");
+const wrap_1 = require("../entity/wrap");
+class DatabaseDriver {
+    config;
+    dependencies;
+    [IDatabaseDriver_1.EntityManagerType];
+    connection;
+    replicas = [];
+    platform;
+    logger;
+    comparator;
+    metadata;
+    constructor(config, dependencies) {
+        this.config = config;
+        this.dependencies = dependencies;
+        this.logger = this.config.getLogger();
+    }
+    async nativeUpdateMany(entityName, where, data, options) {
+        throw new Error(`Batch updates are not supported by ${this.constructor.name} driver`);
+    }
+    createEntityManager(useContext) {
+        const EntityManagerClass = this.config.get('entityManager', EntityManager_1.EntityManager);
+        return new EntityManagerClass(this.config, this, this.metadata, useContext);
+    }
+    /* istanbul ignore next */
+    async findVirtual(entityName, where, options) {
+        throw new Error(`Virtual entities are not supported by ${this.constructor.name} driver.`);
+    }
+    /* istanbul ignore next */
+    async countVirtual(entityName, where, options) {
+        throw new Error(`Counting virtual entities is not supported by ${this.constructor.name} driver.`);
+    }
+    async aggregate(entityName, pipeline) {
+        throw new Error(`Aggregations are not supported by ${this.constructor.name} driver`);
+    }
+    async loadFromPivotTable(prop, owners, where, orderBy, ctx, options, pivotJoin) {
+        throw new Error(`${this.constructor.name} does not use pivot tables`);
+    }
+    async syncCollections(collections, options) {
+        for (const coll of collections) {
+            if (!coll.property.owner) {
+                if (coll.getSnapshot() === undefined) {
+                    throw errors_1.ValidationError.cannotModifyInverseCollection(coll.owner, coll.property);
+                }
+                continue;
+            }
+            /* istanbul ignore next */
+            {
+                const pk = coll.property.targetMeta.primaryKeys[0];
+                const data = { [coll.property.name]: coll.getIdentifiers(pk) };
+                await this.nativeUpdate(coll.owner.constructor.name, (0, wrap_1.helper)(coll.owner).getPrimaryKey(), data, options);
+            }
+        }
+    }
+    mapResult(result, meta, populate = []) {
+        if (!result || !meta) {
+            return result ?? null;
+        }
+        return this.comparator.mapResult(meta.className, result);
+    }
+    async connect() {
+        await this.connection.connect();
+        await Promise.all(this.replicas.map(replica => replica.connect()));
+        return this.connection;
+    }
+    async reconnect() {
+        await this.close(true);
+        await this.connect();
+        return this.connection;
+    }
+    getConnection(type = 'write') {
+        if (type === 'write' || this.replicas.length === 0) {
+            return this.connection;
+        }
+        const rand = utils_1.Utils.randomInt(0, this.replicas.length - 1);
+        return this.replicas[rand];
+    }
+    async close(force) {
+        await Promise.all(this.replicas.map(replica => replica.close(force)));
+        await this.connection.close(force);
+    }
+    getPlatform() {
+        return this.platform;
+    }
+    setMetadata(metadata) {
+        this.metadata = metadata;
+        this.comparator = new utils_1.EntityComparator(this.metadata, this.platform);
+        this.connection.setMetadata(metadata);
+        this.connection.setPlatform(this.platform);
+        this.replicas.forEach(replica => {
+            replica.setMetadata(metadata);
+            replica.setPlatform(this.platform);
+        });
+    }
+    getMetadata() {
+        return this.metadata;
+    }
+    getDependencies() {
+        return this.dependencies;
+    }
+    processCursorOptions(meta, options, orderBy) {
+        const { first, last, before, after, overfetch } = options;
+        const limit = first || last;
+        const isLast = !first && !!last;
+        const definition = utils_1.Cursor.getDefinition(meta, orderBy);
+        const $and = [];
+        // allow POJO as well, we care only about the correct key being present
+        const isCursor = (val, key) => {
+            return !!val && typeof val === 'object' && key in val;
+        };
+        const createCursor = (val, key, inverse = false) => {
+            let def = isCursor(val, key) ? val[key] : val;
+            if (utils_1.Utils.isPlainObject(def)) {
+                def = utils_1.Cursor.for(meta, def, orderBy);
+            }
+            /* istanbul ignore next */
+            const offsets = def ? utils_1.Cursor.decode(def) : [];
+            if (definition.length === offsets.length) {
+                return this.createCursorCondition(definition, offsets, inverse);
+            }
+            /* istanbul ignore next */
+            return {};
+        };
+        if (after) {
+            $and.push(createCursor(after, 'endCursor'));
+        }
+        if (before) {
+            $and.push(createCursor(before, 'startCursor', true));
+        }
+        if (limit) {
+            options.limit = limit + (overfetch ? 1 : 0);
+        }
+        const createOrderBy = (prop, direction) => {
+            if (utils_1.Utils.isPlainObject(direction)) {
+                const value = utils_1.Utils.keys(direction).reduce((o, key) => {
+                    Object.assign(o, createOrderBy(key, direction[key]));
+                    return o;
+                }, {});
+                return ({ [prop]: value });
+            }
+            const desc = direction === enums_1.QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
+            const dir = utils_1.Utils.xor(desc, isLast) ? 'desc' : 'asc';
+            return ({ [prop]: dir });
+        };
+        return {
+            orderBy: definition.map(([prop, direction]) => createOrderBy(prop, direction)),
+            where: ($and.length > 1 ? { $and } : { ...$and[0] }),
+        };
+    }
+    /* istanbul ignore next */
+    createCursorCondition(definition, offsets, inverse) {
+        const createCondition = (prop, direction, offset, eq = false) => {
+            if (utils_1.Utils.isPlainObject(direction)) {
+                const value = utils_1.Utils.keys(direction).reduce((o, key) => {
+                    Object.assign(o, createCondition(key, direction[key], offset[prop][key], eq));
+                    return o;
+                }, {});
+                return ({ [prop]: value });
+            }
+            const desc = direction === enums_1.QueryOrderNumeric.DESC || direction.toString().toLowerCase() === 'desc';
+            const operator = utils_1.Utils.xor(desc, inverse) ? '$lt' : '$gt';
+            return { [prop]: { [operator + (eq ? 'e' : '')]: offset } };
+        };
+        const [order, ...otherOrders] = definition;
+        const [offset, ...otherOffsets] = offsets;
+        const [prop, direction] = order;
+        if (!otherOrders.length) {
+            return createCondition(prop, direction, offset);
+        }
+        return {
+            ...createCondition(prop, direction, offset, true),
+            $or: [
+                createCondition(prop, direction, offset),
+                this.createCursorCondition(otherOrders, otherOffsets, inverse),
+            ],
+        };
+    }
+    /** @internal */
+    mapDataToFieldNames(data, stringifyJsonArrays, properties, convertCustomTypes, object) {
+        if (!properties || data == null) {
+            return data;
+        }
+        data = Object.assign({}, data); // copy first
+        Object.keys(data).forEach(k => {
+            const prop = properties[k];
+            if (!prop) {
+                return;
+            }
+            if (prop.embeddedProps && !prop.object && !object) {
+                const copy = data[k];
+                delete data[k];
+                Object.assign(data, this.mapDataToFieldNames(copy, stringifyJsonArrays, prop.embeddedProps, convertCustomTypes));
+                return;
+            }
+            if (prop.embeddedProps && (object || prop.object)) {
+                const copy = data[k];
+                delete data[k];
+                if (prop.array) {
+                    data[prop.fieldNames[0]] = copy.map((item) => this.mapDataToFieldNames(item, stringifyJsonArrays, prop.embeddedProps, convertCustomTypes, true));
+                }
+                else {
+                    data[prop.fieldNames[0]] = this.mapDataToFieldNames(copy, stringifyJsonArrays, prop.embeddedProps, convertCustomTypes, true);
+                }
+                if (stringifyJsonArrays && prop.array) {
+                    data[prop.fieldNames[0]] = this.platform.convertJsonToDatabaseValue(data[prop.fieldNames[0]]);
+                }
+                return;
+            }
+            if (prop.joinColumns && Array.isArray(data[k])) {
+                const copy = utils_1.Utils.flatten(data[k]);
+                delete data[k];
+                prop.joinColumns.forEach((joinColumn, idx) => data[joinColumn] = copy[idx]);
+                return;
+            }
+            if (prop.customType && convertCustomTypes && !this.platform.isRaw(data[k])) {
+                data[k] = prop.customType.convertToDatabaseValue(data[k], this.platform, { fromQuery: true, key: k, mode: 'query-data' });
+            }
+            if (prop.hasConvertToDatabaseValueSQL && !prop.object && !this.platform.isRaw(data[k])) {
+                const quoted = this.platform.quoteValue(data[k]);
+                const sql = prop.customType.convertToDatabaseValueSQL(quoted, this.platform);
+                data[k] = (0, utils_1.raw)(sql.replace(/\?/g, '\\?'));
+            }
+            /* istanbul ignore next */
+            if (!prop.customType && (Array.isArray(data[k]) || utils_1.Utils.isPlainObject(data[k]))) {
+                data[k] = JSON.stringify(data[k]);
+            }
+            if (prop.fieldNames) {
+                utils_1.Utils.renameKey(data, k, prop.fieldNames[0]);
+            }
+        });
+        return data;
+    }
+    inlineEmbeddables(meta, data, where) {
+        /* istanbul ignore next */
+        if (data == null) {
+            return;
+        }
+        utils_1.Utils.keys(data).forEach(k => {
+            if (utils_1.Utils.isOperator(k)) {
+                utils_1.Utils.asArray(data[k]).forEach(payload => this.inlineEmbeddables(meta, payload, where));
+            }
+        });
+        meta.props.forEach(prop => {
+            if (prop.kind === enums_1.ReferenceKind.EMBEDDED && prop.object && !where && utils_1.Utils.isObject(data[prop.name])) {
+                return;
+            }
+            if (prop.kind === enums_1.ReferenceKind.EMBEDDED && utils_1.Utils.isObject(data[prop.name])) {
+                const props = prop.embeddedProps;
+                let unknownProp = false;
+                Object.keys(data[prop.name]).forEach(kk => {
+                    // explicitly allow `$exists`, `$eq` and `$ne` operators here as they can't be misused this way
+                    const operator = Object.keys(data[prop.name]).some(f => utils_1.Utils.isOperator(f) && !['$exists', '$ne', '$eq'].includes(f));
+                    if (operator) {
+                        throw errors_1.ValidationError.cannotUseOperatorsInsideEmbeddables(meta.className, prop.name, data);
+                    }
+                    if (prop.object && where) {
+                        const inline = (payload, sub, path) => {
+                            if (sub.kind === enums_1.ReferenceKind.EMBEDDED && utils_1.Utils.isObject(payload[sub.embedded[1]])) {
+                                return Object.keys(payload[sub.embedded[1]]).forEach(kkk => {
+                                    if (!sub.embeddedProps[kkk]) {
+                                        throw errors_1.ValidationError.invalidEmbeddableQuery(meta.className, kkk, sub.type);
+                                    }
+                                    inline(payload[sub.embedded[1]], sub.embeddedProps[kkk], [...path, sub.embedded[1]]);
+                                });
+                            }
+                            data[`${path.join('.')}.${sub.embedded[1]}`] = payload[sub.embedded[1]];
+                        };
+                        const parentPropName = kk.substring(0, kk.indexOf('.'));
+                        // we might be using some native JSON operator, e.g. with mongodb's `$geoWithin` or `$exists`
+                        if (props[kk]) {
+                            /* istanbul ignore next */
+                            inline(data[prop.name], props[kk] || props[parentPropName], [prop.name]);
+                        }
+                        else if (props[parentPropName]) {
+                            data[`${prop.name}.${kk}`] = data[prop.name][kk];
+                        }
+                        else {
+                            unknownProp = true;
+                        }
+                    }
+                    else if (props[kk]) {
+                        data[props[kk].name] = data[prop.name][props[kk].embedded[1]];
+                    }
+                    else {
+                        throw errors_1.ValidationError.invalidEmbeddableQuery(meta.className, kk, prop.type);
+                    }
+                });
+                if (!unknownProp) {
+                    delete data[prop.name];
+                }
+            }
+        });
+    }
+    getPrimaryKeyFields(entityName) {
+        const meta = this.metadata.find(entityName);
+        return meta ? utils_1.Utils.flatten(meta.getPrimaryProps().map(pk => pk.fieldNames)) : [this.config.getNamingStrategy().referenceColumnName()];
+    }
+    createReplicas(cb) {
+        const replicas = this.config.get('replicas', []);
+        const ret = [];
+        const props = ['dbName', 'clientUrl', 'host', 'port', 'user', 'password', 'multipleStatements', 'pool', 'name'];
+        replicas.forEach((conf) => {
+            props.forEach(prop => conf[prop] = prop in conf ? conf[prop] : this.config.get(prop));
+            ret.push(cb(conf));
+        });
+        return ret;
+    }
+    async lockPessimistic(entity, options) {
+        throw new Error(`Pessimistic locks are not supported by ${this.constructor.name} driver`);
+    }
+    /**
+     * @inheritDoc
+     */
+    convertException(exception) {
+        if (exception instanceof exceptions_1.DriverException) {
+            return exception;
+        }
+        return this.platform.getExceptionConverter().convertException(exception);
+    }
+    rethrow(promise) {
+        return promise.catch(e => {
+            throw this.convertException(e);
+        });
+    }
+    /**
+     * @internal
+     */
+    getTableName(meta, options) {
+        const tableName = this.platform.quoteIdentifier(meta.tableName);
+        const schema = this.getSchemaName(meta, options);
+        if (schema) {
+            return this.platform.quoteIdentifier(schema) + '.' + tableName;
+        }
+        return tableName;
+    }
+    /**
+     * @internal
+     */
+    getSchemaName(meta, options) {
+        if (meta?.schema && meta.schema !== '*') {
+            return meta.schema;
+        }
+        if (options?.schema === '*') {
+            return this.config.get('schema');
+        }
+        const schemaName = meta?.schema === '*' ? this.config.get('schema') : meta?.schema;
+        return options?.schema ?? schemaName ?? this.config.get('schema');
+    }
+}
+exports.DatabaseDriver = DatabaseDriver;

package/drivers/IDatabaseDriver.d.ts

@@ -0,0 +1,193 @@
+import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, QBFilterQuery, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate } from '../typings';
+import type { Connection, QueryResult, Transaction } from '../connections';
+import type { FlushMode, LockMode, QueryOrderMap, QueryFlag, LoadStrategy, PopulateHint } from '../enums';
+import type { Platform } from '../platforms';
+import type { MetadataStorage } from '../metadata';
+import type { Collection } from '../entity/Collection';
+import type { EntityManager } from '../EntityManager';
+import type { DriverException } from '../exceptions';
+import type { Configuration } from '../utils/Configuration';
+import type { LoggingOptions, LogContext } from '../logging';
+export declare const EntityManagerType: unique symbol;
+export interface IDatabaseDriver<C extends Connection = Connection> {
+    [EntityManagerType]: EntityManager<this>;
+    readonly config: Configuration;
+    createEntityManager<D extends IDatabaseDriver = IDatabaseDriver>(useContext?: boolean): D[typeof EntityManagerType];
+    connect(): Promise<C>;
+    close(force?: boolean): Promise<void>;
+    reconnect(): Promise<C>;
+    getConnection(type?: ConnectionType): C;
+    /**
+     * Finds selection of entities
+     */
+    find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    /**
+     * Finds single entity (table row, document)
+     */
+    findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    nativeDelete<T extends object>(entityName: string, where: FilterQuery<T>, options?: NativeDeleteOptions<T>): Promise<QueryResult<T>>;
+    syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
+    count<T extends object, P extends string = never>(entityName: string, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
+    aggregate(entityName: string, pipeline: any[]): Promise<any[]>;
+    mapResult<T extends object>(result: EntityDictionary<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[]): EntityData<T> | null;
+    /**
+     * When driver uses pivot tables for M:N, this method will load identifiers for given collections from them
+     */
+    loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<T>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
+    getPlatform(): Platform;
+    setMetadata(metadata: MetadataStorage): void;
+    getMetadata(): MetadataStorage;
+    /**
+     * Returns name of the underlying database dependencies (e.g. `mongodb` or `mysql2`)
+     * for SQL drivers it also returns `knex` in the array as connectors are not used directly there
+     */
+    getDependencies(): string[];
+    lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
+    /**
+     * Converts native db errors to standardized driver exceptions
+     */
+    convertException(exception: Error): DriverException;
+    /**
+     * @internal
+     */
+    getSchemaName(meta?: EntityMetadata, options?: {
+        schema?: string;
+    }): string | undefined;
+}
+export type EntityField<T, P extends string = '*'> = keyof T | '*' | AutoPath<T, P, '*'>;
+export type OrderDefinition<T> = (QueryOrderMap<T> & {
+    0?: never;
+}) | QueryOrderMap<T>[];
+export interface FindAllOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends FindOptions<T, P, F, E> {
+    where?: FilterQuery<T>;
+}
+export type FilterOptions = Dictionary<boolean | Dictionary> | string[] | boolean;
+export interface FindOptions<Entity, Hint extends string = never, Fields extends string = '*', Excludes extends string = never> {
+    populate?: Populate<Entity, Hint>;
+    populateWhere?: ObjectQuery<Entity> | PopulateHint | `${PopulateHint}`;
+    populateOrderBy?: OrderDefinition<Entity>;
+    fields?: readonly AutoPath<Entity, Fields, '*'>[];
+    exclude?: readonly AutoPath<Entity, Excludes>[];
+    orderBy?: OrderDefinition<Entity>;
+    cache?: boolean | number | [string, number];
+    limit?: number;
+    offset?: number;
+    /** Fetch items `before` this cursor. */
+    before?: string | {
+        startCursor: string | null;
+    } | FilterObject<Entity>;
+    /** Fetch items `after` this cursor. */
+    after?: string | {
+        endCursor: string | null;
+    } | FilterObject<Entity>;
+    /** Fetch `first` N items. */
+    first?: number;
+    /** Fetch `last` N items. */
+    last?: number;
+    /** Fetch one more item than `first`/`last`, enabled automatically in `em.findByCursor` to check if there is a next page. */
+    overfetch?: boolean;
+    refresh?: boolean;
+    convertCustomTypes?: boolean;
+    disableIdentityMap?: boolean;
+    schema?: string;
+    flags?: QueryFlag[];
+    /** sql only */
+    groupBy?: string | string[];
+    having?: QBFilterQuery<Entity>;
+    /** sql only */
+    strategy?: LoadStrategy | `${LoadStrategy}`;
+    flushMode?: FlushMode | `${FlushMode}`;
+    filters?: FilterOptions;
+    /** sql only */
+    lockMode?: Exclude<LockMode, LockMode.OPTIMISTIC>;
+    /** sql only */
+    lockTableAliases?: string[];
+    ctx?: Transaction;
+    connectionType?: ConnectionType;
+    /** sql only */
+    indexHint?: string;
+    /** sql only */
+    comments?: string | string[];
+    /** sql only */
+    hintComments?: string | string[];
+    loggerContext?: LogContext;
+    logging?: LoggingOptions;
+}
+export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'offset'> {
+}
+export interface FindOneOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
+    lockMode?: LockMode;
+    lockVersion?: number | Date;
+}
+export interface FindOneOrFailOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends FindOneOptions<T, P, F, E> {
+    failHandler?: (entityName: string, where: Dictionary | IPrimaryKey | any) => Error;
+    strict?: boolean;
+}
+export interface NativeInsertUpdateOptions<T> {
+    convertCustomTypes?: boolean;
+    ctx?: Transaction;
+    schema?: string;
+    /** `nativeUpdate()` only option */
+    upsert?: boolean;
+}
+export interface NativeInsertUpdateManyOptions<T> extends NativeInsertUpdateOptions<T> {
+    processCollections?: boolean;
+}
+export interface UpsertOptions<Entity> extends Omit<NativeInsertUpdateOptions<Entity>, 'upsert'> {
+    onConflictFields?: (keyof Entity)[];
+    onConflictAction?: 'ignore' | 'merge';
+    onConflictMergeFields?: (keyof Entity)[];
+    onConflictExcludeFields?: (keyof Entity)[];
+}
+export interface UpsertManyOptions<Entity> extends UpsertOptions<Entity> {
+    batchSize?: number;
+}
+export interface CountOptions<T extends object, P extends string = never> {
+    filters?: FilterOptions;
+    schema?: string;
+    groupBy?: string | readonly string[];
+    having?: QBFilterQuery<T>;
+    cache?: boolean | number | [string, number];
+    populate?: Populate<T, P>;
+    ctx?: Transaction;
+    connectionType?: ConnectionType;
+    /** sql only */
+    indexHint?: string;
+    /** sql only */
+    comments?: string | string[];
+    /** sql only */
+    hintComments?: string | string[];
+    loggerContext?: LogContext;
+    logging?: LoggingOptions;
+}
+export interface UpdateOptions<T> {
+    filters?: FilterOptions;
+    schema?: string;
+    ctx?: Transaction;
+}
+export interface DeleteOptions<T> extends DriverMethodOptions {
+    filters?: FilterOptions;
+}
+export interface NativeDeleteOptions<T> extends DriverMethodOptions {
+    filters?: FilterOptions;
+}
+export interface LockOptions extends DriverMethodOptions {
+    lockMode?: LockMode;
+    lockVersion?: number | Date;
+    lockTableAliases?: string[];
+    logging?: LoggingOptions;
+}
+export interface DriverMethodOptions {
+    ctx?: Transaction;
+    schema?: string;
+}
+export interface GetReferenceOptions {
+    wrapped?: boolean;
+    convertCustomTypes?: boolean;
+    schema?: string;
+}

package/drivers/IDatabaseDriver.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityManagerType = void 0;
+exports.EntityManagerType = Symbol('EntityManagerType');

package/drivers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './IDatabaseDriver';
+export * from './DatabaseDriver';

package/drivers/index.js

@@ -0,0 +1,18 @@
+"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("./IDatabaseDriver"), exports);
+__exportStar(require("./DatabaseDriver"), exports);