@exogee/graphweaver-mikroorm 0.1.0-alpha.1 → 0.1.0-alpha.6

package/lib/base-resolver/assign.d.ts

@@ -3,5 +3,5 @@ interface AssignOptions {
     create?: boolean;
     update?: boolean;
 }
-export declare const assign: <T extends Partial<T>>(entity: T, data: EntityData<T>, options?: AssignOptions | undefined, visited?: Set<Partial<any>>) => Promise<T>;
+export declare const assign: <T extends Partial<T>>(entity: T, data: EntityData<T>, options?: AssignOptions, visited?: Set<Partial<any>>) => Promise<T>;
 export {};

package/lib/base-resolver/assign.js

@@ -0,0 +1,160 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var assign_exports = {};
+__export(assign_exports, {
+  assign: () => assign
+});
+module.exports = __toCommonJS(assign_exports);
+var import_core = require("@mikro-orm/core");
+var import_logger = require("@exogee/logger");
+var import_database = require("../database");
+const assign = async (entity, data, options, visited = /* @__PURE__ */ new Set()) => {
+  var _a;
+  if (visited.has(entity))
+    return entity;
+  visited.add(entity);
+  const metadata = (0, import_core.wrap)(entity, true).__meta;
+  for (const [property, value] of Object.entries(data)) {
+    const entityPropertyValue = entity[property];
+    const propertyMetadata = metadata.properties[property];
+    if ((propertyMetadata == null ? void 0 : propertyMetadata.reference) === import_core.ReferenceType.MANY_TO_MANY || (propertyMetadata == null ? void 0 : propertyMetadata.reference) === import_core.ReferenceType.ONE_TO_MANY) {
+      if (!Array.isArray(value))
+        throw new Error(
+          `Value is not an array while trying to assign to collection property ${property} on entity ${metadata.name}`
+        );
+      if (!(entityPropertyValue instanceof import_core.Collection)) {
+        throw new Error(
+          `Tried to merge array into non-collection property ${property} on entity ${metadata.name}`
+        );
+      }
+      const visitedEntities = /* @__PURE__ */ new Set();
+      for (const subvalue of value) {
+        let entity2;
+        if (subvalue.id) {
+          entity2 = import_database.Database.em.getUnitOfWork().getById(propertyMetadata.type, subvalue.id);
+          if (!entity2) {
+            if (Object.keys(subvalue).length === 1) {
+              entity2 = import_database.Database.em.getReference(propertyMetadata.type, subvalue.id);
+            } else {
+              import_logger.logger.warn(
+                `Doing a full database fetch for ${propertyMetadata.type} with id ${subvalue.id}, this should ideally be prefetched into the Unit of Work before calling assign() for performance`
+              );
+              entity2 = (_a = await import_database.Database.em.findOne(propertyMetadata.type, {
+                id: subvalue.id
+              })) != null ? _a : void 0;
+            }
+          }
+          if (!entity2) {
+            throw new Error(
+              `Attempted to assign as an update to '${propertyMetadata.name}' property of ${metadata.name} Entity, but even after a full fetch to the database ${propertyMetadata.type} with ID of ${subvalue.id} could not be found.`
+            );
+          }
+        }
+        const newEntity = await createOrAssignEntity({
+          entity: entity2,
+          entityType: propertyMetadata.type,
+          data: subvalue,
+          options,
+          visited
+        });
+        entityPropertyValue.add(newEntity);
+        visitedEntities.add(newEntity);
+      }
+      entityPropertyValue.remove(
+        ...entityPropertyValue.getItems().filter((entity2) => !visitedEntities.has(entity2))
+      );
+    } else if ((propertyMetadata == null ? void 0 : propertyMetadata.reference) == import_core.ReferenceType.MANY_TO_ONE || (propertyMetadata == null ? void 0 : propertyMetadata.reference) === import_core.ReferenceType.ONE_TO_ONE) {
+      if (value === null) {
+        entity[property] = null;
+      } else {
+        const valueKeys = Object.keys(value);
+        if (valueKeys.length === 1 && valueKeys[0] === "id") {
+          entity[property] = import_database.Database.em.getReference(
+            propertyMetadata.type,
+            value.id
+          );
+        } else {
+          if (entityPropertyValue && !import_core.Reference.isReference(entityPropertyValue)) {
+            throw new Error(
+              `Trying to merge to related property ${property} on entity ${metadata.name} which is not a reference.`
+            );
+          }
+          if (entityPropertyValue && !entityPropertyValue.isInitialized()) {
+            throw new Error(
+              `Trying to merge to related property ${property} on entity ${metadata.name} which is not initialised.`
+            );
+          }
+          const newEntity = await createOrAssignEntity({
+            entity: entityPropertyValue == null ? void 0 : entityPropertyValue.unwrap(),
+            entityType: propertyMetadata.type,
+            data: value,
+            options,
+            visited
+          });
+          entity[property] = import_core.Reference.create(newEntity);
+        }
+      }
+    } else {
+      entity[property] = value;
+    }
+  }
+  return entity;
+};
+const createOrAssignEntity = ({
+  entity,
+  entityType,
+  data,
+  options,
+  visited
+}) => {
+  var _a, _b;
+  const create = (_a = options == null ? void 0 : options.create) != null ? _a : true;
+  const update = (_b = options == null ? void 0 : options.update) != null ? _b : true;
+  if (data.id) {
+    if (!update) {
+      throw new Error(
+        `Updates are disabled, but update value ${JSON.stringify(
+          data
+        )} was passed which has an ID property.`
+      );
+    }
+    if (!entity) {
+      throw new Error(
+        `Tried to update with data ${JSON.stringify(
+          data
+        )} but entity could not be located to update.`
+      );
+    }
+    return assign(entity, data, options, visited);
+  } else {
+    if (!create) {
+      throw new Error(
+        `Creates are disabled, but update value ${JSON.stringify(
+          data
+        )} was passed which does not have an ID property.`
+      );
+    }
+    const entity2 = import_database.Database.em.create(entityType, {});
+    return assign(entity2, data, options, visited);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assign
+});

package/lib/base-resolver/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var base_resolver_exports = {};
+module.exports = __toCommonJS(base_resolver_exports);
+__reExport(base_resolver_exports, require("./provider"), module.exports);

package/lib/base-resolver/provider.js

@@ -0,0 +1,338 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var provider_exports = {};
+__export(provider_exports, {
+  MikroBackendProvider: () => MikroBackendProvider,
+  gqlToMikro: () => gqlToMikro,
+  mapAndAssignKeys: () => mapAndAssignKeys,
+  visitPathForPopulate: () => visitPathForPopulate
+});
+module.exports = __toCommonJS(provider_exports);
+var import_logger = require("@exogee/logger");
+var import__ = require("..");
+var import_errors = require("../utils/errors");
+var import_assign = require("./assign");
+const objectOperations = /* @__PURE__ */ new Set(["_and", "_or", "_not"]);
+const mikroObjectOperations = /* @__PURE__ */ new Set(["$and", "$or", "$not"]);
+const nonJoinKeys = /* @__PURE__ */ new Set([
+  "$and",
+  "$gt",
+  "$gte",
+  "$in",
+  "$lt",
+  "$lte",
+  "$ne",
+  "$nin",
+  "$not",
+  "$or",
+  "$like",
+  "$ilike",
+  "$null",
+  "$notnull",
+  "id"
+]);
+const appendPath = (path, newPath) => path.length ? `${path}.${newPath}` : newPath;
+const visitPathForPopulate = (entityName, updateArgBranch, populateBranch = "") => {
+  var _a, _b, _c, _d;
+  const { properties } = import__.Database.em.getMetadata().get(entityName);
+  const collectedPaths = populateBranch ? /* @__PURE__ */ new Set([populateBranch]) : /* @__PURE__ */ new Set([]);
+  for (const [key, value] of Object.entries(updateArgBranch != null ? updateArgBranch : {})) {
+    if (((_a = properties[key]) == null ? void 0 : _a.reference) === import__.ReferenceType.ONE_TO_ONE || ((_b = properties[key]) == null ? void 0 : _b.reference) === import__.ReferenceType.ONE_TO_MANY || ((_c = properties[key]) == null ? void 0 : _c.reference) === import__.ReferenceType.MANY_TO_ONE || ((_d = properties[key]) == null ? void 0 : _d.reference) === import__.ReferenceType.MANY_TO_MANY) {
+      if (Array.isArray(value)) {
+        collectedPaths.add(appendPath(populateBranch, key));
+        for (const entry of value) {
+          const newPaths = visitPathForPopulate(
+            properties[key].type,
+            entry,
+            appendPath(populateBranch, key)
+          );
+          newPaths.forEach((path) => collectedPaths.add(path));
+        }
+      } else if (typeof value === "object") {
+        const newPaths = visitPathForPopulate(
+          properties[key].type,
+          value,
+          appendPath(populateBranch, key)
+        );
+        newPaths.forEach((path) => collectedPaths.add(path));
+      }
+    }
+  }
+  return collectedPaths;
+};
+const gqlToMikro = (filter) => {
+  if (Array.isArray(filter)) {
+    return filter.map((element) => gqlToMikro(element));
+  } else if (typeof filter === "object") {
+    for (const key of Object.keys(filter)) {
+      if (filter[key] === null)
+        continue;
+      if (objectOperations.has(key)) {
+        filter[key.replace("_", "$")] = gqlToMikro(filter[key]);
+        delete filter[key];
+      } else if (typeof filter[key] === "object" && !Array.isArray(filter[key])) {
+        filter[key] = gqlToMikro(filter[key]);
+      } else if (key.indexOf("_") >= 0) {
+        const [newKey, operator] = key.split("_");
+        const newValue = { [`$${operator}`]: gqlToMikro(filter[key]) };
+        if (typeof filter[newKey] !== "undefined") {
+          filter[newKey] = { ...filter[newKey], ...newValue };
+        } else {
+          filter[newKey] = newValue;
+        }
+        delete filter[key];
+      }
+    }
+  }
+  return filter;
+};
+const mapAndAssignKeys = (result, entityType, inputArgs) => {
+  const cleanInput = JSON.parse(JSON.stringify(inputArgs));
+  return (0, import_assign.assign)(result, cleanInput);
+};
+class MikroBackendProvider {
+  constructor(mikroType) {
+    this.backendId = "mikro-orm";
+    this.supportsInFilter = true;
+    this.getRepository = () => {
+      const repository = import__.Database.em.getRepository(this.entityType);
+      if (!repository)
+        throw new Error("Could not find repository for " + this.entityType.name);
+      return repository;
+    };
+    this.entityType = mikroType;
+  }
+  applyWhereClause(where) {
+    const query = this.getRepository().createQueryBuilder();
+    const joinKeysUsed = /* @__PURE__ */ new Map();
+    if (where) {
+      const visit = (current, table = "e0") => {
+        var _a;
+        if (Array.isArray(current)) {
+          for (const element of current) {
+            visit(element, table);
+          }
+        } else if (typeof current === "object") {
+          for (const key of Object.keys(current)) {
+            const shouldJoin = current[key] !== null && typeof current[key] === "object" && Object.keys(current[key]).filter((key2) => !nonJoinKeys.has(key2)).length > 0;
+            if (mikroObjectOperations.has(key)) {
+              visit(current[key], table);
+            } else if (shouldJoin) {
+              const keyUseCount = joinKeysUsed.has(key) ? ((_a = joinKeysUsed.get(key)) != null ? _a : 0) + 1 : 1;
+              const joinKey = joinKeysUsed.has(key) ? `${key}${keyUseCount}` : key;
+              query.leftJoin(`${table}.${key}`, joinKey);
+              joinKeysUsed.set(joinKey, keyUseCount);
+              visit(current[key], key);
+            }
+            if (current[key] !== null && typeof current[key] === "object" && Object.keys(current[key]).length === 0) {
+              delete current[key];
+            }
+          }
+        }
+      };
+      visit(where);
+      if (Object.keys(where).length > 0) {
+        query.andWhere(where);
+      }
+    }
+    return query;
+  }
+  async find(filter, pagination, additionalOptionsForBackend) {
+    import_logger.logger.trace(`Running find ${this.entityType.name} with filter`, {
+      filter: JSON.stringify(filter)
+    });
+    const where = filter ? gqlToMikro(JSON.parse(JSON.stringify(filter))) : void 0;
+    const query = this.applyWhereClause(where);
+    (pagination == null ? void 0 : pagination.limit) && query.limit(pagination.limit);
+    (pagination == null ? void 0 : pagination.offset) && query.offset(pagination.offset);
+    (pagination == null ? void 0 : pagination.orderBy) && query.orderBy({ ...pagination.orderBy });
+    query.setFlag(import__.QueryFlag.DISTINCT);
+    const driver = import__.Database.em.getDriver();
+    const meta = import__.Database.em.getMetadata().get(this.entityType.name);
+    query.populate(driver.autoJoinOneToOneOwner(meta, []));
+    if (additionalOptionsForBackend == null ? void 0 : additionalOptionsForBackend.populate) {
+      query.populate(additionalOptionsForBackend.populate);
+    }
+    const result = await query.getResult();
+    import_logger.logger.trace(`find ${this.entityType.name} result: ${result.length} rows`);
+    return result;
+  }
+  async findOne(id) {
+    import_logger.logger.trace(`Running findOne ${this.entityType.name} with ID ${id}`);
+    const result = await import__.Database.em.findOne(this.entityType, id);
+    import_logger.logger.trace(`findOne ${this.entityType.name} result`, { result });
+    return result;
+  }
+  async findByRelatedId(entity, relatedField, relatedFieldIds, filter) {
+    const queryFilter = {
+      $and: [{ [relatedField]: { $in: relatedFieldIds } }, ...[filter != null ? filter : []]]
+    };
+    const populate = [relatedField];
+    const result = await import__.Database.em.find(entity, queryFilter, { populate });
+    return result;
+  }
+  async updateOne(id, updateArgs) {
+    import_logger.logger.trace(`Running update ${this.entityType.name} with args`, {
+      id,
+      updateArgs: JSON.stringify(updateArgs)
+    });
+    const entity = await import__.Database.em.findOne(this.entityType, id, {
+      populate: [...visitPathForPopulate(this.entityType.name, updateArgs)]
+    });
+    if (entity === null) {
+      throw new Error(`Unable to locate ${this.entityType.name} with ID: '${id}' for updating.`);
+    }
+    if (updateArgs == null ? void 0 : updateArgs.version) {
+      try {
+        await import__.Database.em.lock(entity, import__.LockMode.OPTIMISTIC, updateArgs.version);
+        delete updateArgs.version;
+      } catch (err) {
+        throw new import_errors.OptimisticLockError(err == null ? void 0 : err.message, { entity });
+      }
+    }
+    await mapAndAssignKeys(entity, this.entityType, updateArgs);
+    await this.getRepository().persistAndFlush(entity);
+    import_logger.logger.trace(`update ${this.entityType.name} entity`, entity);
+    return entity;
+  }
+  async updateMany(updateItems) {
+    import_logger.logger.trace(`Running update many ${this.entityType.name} with args`, {
+      updateItems: JSON.stringify(updateItems)
+    });
+    const entities = await import__.Database.transactional(async () => {
+      return Promise.all(
+        updateItems.map(async (item) => {
+          if (!(item == null ? void 0 : item.id))
+            throw new Error("You must pass an ID for this entity to update it.");
+          const entity = await import__.Database.em.findOneOrFail(this.entityType, item.id, {
+            populate: [...visitPathForPopulate(this.entityType.name, item)]
+          });
+          await mapAndAssignKeys(entity, this.entityType, item);
+          import__.Database.em.persist(entity);
+          return entity;
+        })
+      );
+    });
+    import_logger.logger.trace(`updated ${this.entityType.name} items `, entities);
+    return entities;
+  }
+  async createOrUpdateMany(items) {
+    import_logger.logger.trace(`Running create or update many for ${this.entityType.name} with args`, {
+      items: JSON.stringify(items)
+    });
+    const entities = await import__.Database.transactional(async () => {
+      return Promise.all(
+        items.map(async (item) => {
+          let entity;
+          const { id } = item;
+          if (id) {
+            entity = await import__.Database.em.findOneOrFail(this.entityType, id, {
+              populate: [...visitPathForPopulate(this.entityType.name, item)]
+            });
+            import_logger.logger.trace(`Running update on ${this.entityType.name} with item`, {
+              item: JSON.stringify(item)
+            });
+            await mapAndAssignKeys(entity, this.entityType, item);
+          } else {
+            entity = new this.entityType();
+            await mapAndAssignKeys(entity, this.entityType, item);
+            import_logger.logger.trace(`Running create on ${this.entityType.name} with item`, {
+              item: JSON.stringify(item)
+            });
+          }
+          import__.Database.em.persist(entity);
+          return entity;
+        })
+      );
+    });
+    import_logger.logger.trace(`created or updated ${this.entityType.name} items `, entities);
+    return entities;
+  }
+  async createOne(createArgs) {
+    import_logger.logger.trace(`Running create ${this.entityType.name} with args`, {
+      createArgs: JSON.stringify(createArgs)
+    });
+    const entity = new this.entityType();
+    await mapAndAssignKeys(entity, this.entityType, createArgs);
+    await this.getRepository().persistAndFlush(entity);
+    import_logger.logger.trace(`create ${this.entityType.name} result`, entity);
+    return entity;
+  }
+  async createMany(createItems) {
+    import_logger.logger.trace(`Running create ${this.entityType.name} with args`, {
+      createArgs: JSON.stringify(createItems)
+    });
+    const entities = await import__.Database.transactional(async () => {
+      return Promise.all(
+        createItems.map(async (item) => {
+          const entity = new this.entityType();
+          await mapAndAssignKeys(entity, this.entityType, item);
+          import__.Database.em.persist(entity);
+          return entity;
+        })
+      );
+    });
+    import_logger.logger.trace(`created ${this.entityType.name} items `, entities);
+    return entities;
+  }
+  async deleteOne(id) {
+    import_logger.logger.trace(`Running delete ${this.entityType.name} with id ${id}`);
+    const deletedRows = await this.getRepository().nativeDelete({
+      id
+    });
+    if (deletedRows > 1) {
+      throw new Error("Multiple deleted rows");
+    }
+    import_logger.logger.trace(`delete ${this.entityType.name} result: deleted ${deletedRows} row(s)`);
+    return deletedRows === 1;
+  }
+  async deleteMany(ids) {
+    import_logger.logger.trace(`Running delete ${this.entityType.name} with ids ${ids}`);
+    const deletedRows = await import__.Database.transactional(async () => {
+      const deletedCount = await this.getRepository().nativeDelete({
+        id: { $in: ids }
+      });
+      if (deletedCount !== ids.length) {
+        throw new Error("We did not delete all the rows, rolling back");
+      }
+      return deletedCount;
+    });
+    import_logger.logger.trace(`delete ${this.entityType.name} result: deleted ${deletedRows} row(s)`);
+    return deletedRows === ids.length;
+  }
+  getRelatedEntityId(entity, relatedIdField) {
+    if (typeof entity === "string") {
+      return entity;
+    }
+    if (entity.id) {
+      return entity.id;
+    }
+    throw new Error(`Unknown entity without an id: ${JSON.stringify(entity)}`);
+  }
+  isCollection(entity) {
+    return import__.Utils.isCollection(entity);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MikroBackendProvider,
+  gqlToMikro,
+  mapAndAssignKeys,
+  visitPathForPopulate
+});

package/lib/config.d.ts

@@ -1,2 +1,2 @@
-export declare const requireEnvironmentVariable: (envStr: string, warnOnly?: boolean | undefined) => string | undefined;
+export declare const requireEnvironmentVariable: (envStr: string, warnOnly?: boolean) => string | undefined;
 export declare const config: {};

package/lib/config.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+__export(config_exports, {
+  config: () => config,
+  requireEnvironmentVariable: () => requireEnvironmentVariable
+});
+module.exports = __toCommonJS(config_exports);
+var import_logger = require("@exogee/logger");
+const requireEnvironmentVariable = (envStr, warnOnly) => {
+  const envVar = process.env[envStr];
+  if (!envVar) {
+    if (warnOnly) {
+      import_logger.logger.warn(`${envStr} is required in environment.`);
+      return;
+    }
+    throw new Error(`${envStr} required but not found.`);
+  }
+  return envVar;
+};
+const config = {};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  config,
+  requireEnvironmentVariable
+});

package/lib/database.d.ts

@@ -23,11 +23,11 @@ declare class DatabaseImplementation {
     get rawConnection(): import("@mikro-orm/postgresql").PostgreSqlConnection;
     private getConnectionInfo;
     getRepository: <T extends Partial<T>>(entityName: EntityName<T>) => import("@mikro-orm/core").GetRepository<T, import("@mikro-orm/postgresql").EntityRepository<T>>;
-    connect: (connectionOptions?: ConnectionOptions | undefined) => Promise<MikroORM<IDatabaseDriver<Connection>>>;
+    connect: (connectionOptions?: ConnectionOptions) => Promise<MikroORM<IDatabaseDriver<Connection>>>;
     close: () => Promise<void>;
 }
 export declare const Database: DatabaseImplementation;
 export declare const checkDatabase: () => Promise<any>;
 export declare const getDbSchema: () => Promise<string>;
-export declare const clearDatabaseContext: (req?: any, res?: any, next?: any, connectionOptions?: ConnectionOptions | undefined) => Promise<any>;
+export declare const clearDatabaseContext: (req?: any, res?: any, next?: any, connectionOptions?: ConnectionOptions) => Promise<any>;
 export {};