@exogee/graphweaver-mikroorm 0.1.0-alpha.0

package/lib/index.js

@@ -0,0 +1,1002 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+
+// ../../packages/mikroorm/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AuditChange: () => AuditChange,
+  AuditRelatedEntityChange: () => AuditRelatedEntityChange,
+  AuthenticationContext: () => AuthenticationContext,
+  BaseEntity: () => BaseEntity,
+  ChangeSetType: () => import_core10.ChangeSetType,
+  Collection: () => import_core10.Collection,
+  Database: () => Database,
+  DatabaseObjectNotFoundException: () => import_core10.DatabaseObjectNotFoundException,
+  DateType: () => DateType,
+  EntityManager: () => import_core10.EntityManager,
+  EntityRepository: () => import_core10.EntityRepository,
+  IsolationLevel: () => IsolationLevel,
+  LockMode: () => import_core10.LockMode,
+  MikroBackendProvider: () => MikroBackendProvider,
+  PrimaryKeyType: () => import_core10.PrimaryKeyType,
+  QueryFlag: () => import_core10.QueryFlag,
+  QueryOrder: () => import_core10.QueryOrder,
+  Reference: () => import_core10.Reference,
+  ReferenceType: () => import_core10.ReferenceType,
+  SqlEntityManager: () => import_postgresql2.SqlEntityManager,
+  SqlEntityRepository: () => import_postgresql2.SqlEntityRepository,
+  Subscriber: () => import_core10.Subscriber,
+  Time: () => Time,
+  TimeType: () => TimeType,
+  UniqueConstraintViolationException: () => import_core10.UniqueConstraintViolationException,
+  Utils: () => import_core10.Utils,
+  checkDatabase: () => checkDatabase,
+  clearDatabaseContext: () => clearDatabaseContext,
+  getDbSchema: () => getDbSchema,
+  gqlToMikro: () => gqlToMikro,
+  mapAndAssignKeys: () => mapAndAssignKeys,
+  visitPathForPopulate: () => visitPathForPopulate,
+  wrap: () => import_core10.wrap
+});
+module.exports = __toCommonJS(src_exports);
+var import_reflect_metadata3 = require("reflect-metadata");
+var dotenv = __toESM(require("dotenv"));
+
+// ../../packages/mikroorm/src/base-resolver/provider.ts
+var import_logger4 = require("@exogee/logger");
+
+// ../../packages/mikroorm/src/utils/errors.ts
+var import_apollo_server_core = require("apollo-server-core");
+var OptimisticLockError = class extends import_apollo_server_core.ApolloError {
+  constructor(message, extensions) {
+    super(message, "OPTIMISTIC_LOCK_ERROR", extensions);
+  }
+};
+
+// ../../packages/mikroorm/src/base-resolver/assign.ts
+var import_core7 = require("@mikro-orm/core");
+var import_logger3 = require("@exogee/logger");
+
+// ../../packages/mikroorm/src/database.ts
+var import_reflect_metadata2 = require("reflect-metadata");
+
+// ../../packages/mikroorm/src/utils/change-tracker.ts
+var import_core5 = require("@mikro-orm/core");
+
+// ../../packages/mikroorm/src/entities/audit-change.ts
+var import_core3 = require("@mikro-orm/core");
+
+// ../../packages/mikroorm/src/entities/audit-related-entity-change.ts
+var import_core2 = require("@mikro-orm/core");
+
+// ../../packages/mikroorm/src/entities/base-entity.ts
+var import_core = require("@mikro-orm/core");
+var BaseEntity = class {
+  isReference(_, dataField) {
+    return import_core.Reference.isReference(dataField);
+  }
+  isCollection(fieldName, dataField) {
+    return import_core.Utils.isCollection(dataField);
+  }
+};
+
+// ../../packages/mikroorm/src/entities/audit-related-entity-change.ts
+var AuditRelatedEntityChange = class extends BaseEntity {
+};
+__decorateClass([
+  (0, import_core2.PrimaryKey)({ type: import_core2.BigIntType })
+], AuditRelatedEntityChange.prototype, "id", 2);
+__decorateClass([
+  (0, import_core2.ManyToOne)(() => AuditChange, { onDelete: "cascade", wrappedReference: true })
+], AuditRelatedEntityChange.prototype, "change", 2);
+__decorateClass([
+  (0, import_core2.Property)({ type: "string" })
+], AuditRelatedEntityChange.prototype, "relatedEntityType", 2);
+__decorateClass([
+  (0, import_core2.Property)({ type: "string" })
+], AuditRelatedEntityChange.prototype, "relatedEntityId", 2);
+AuditRelatedEntityChange = __decorateClass([
+  (0, import_core2.Entity)(),
+  (0, import_core2.Index)({ properties: ["relatedEntityType", "relatedEntityId"] })
+], AuditRelatedEntityChange);
+
+// ../../packages/mikroorm/src/entities/audit-change.ts
+var AuditChange = class extends BaseEntity {
+  constructor() {
+    super(...arguments);
+    this.createdAt = new Date();
+  }
+};
+__decorateClass([
+  (0, import_core3.PrimaryKey)({ type: import_core3.BigIntType })
+], AuditChange.prototype, "id", 2);
+__decorateClass([
+  (0, import_core3.Enum)({ items: () => import_core3.ChangeSetType, type: "string" })
+], AuditChange.prototype, "type", 2);
+__decorateClass([
+  (0, import_core3.Property)({ type: "string" })
+], AuditChange.prototype, "entityId", 2);
+__decorateClass([
+  (0, import_core3.Property)({ type: "string" })
+], AuditChange.prototype, "entityType", 2);
+__decorateClass([
+  (0, import_core3.Property)({ type: "string" })
+], AuditChange.prototype, "createdBy", 2);
+__decorateClass([
+  (0, import_core3.Property)({ type: "date" })
+], AuditChange.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_core3.Property)({ type: "json", nullable: true })
+], AuditChange.prototype, "data", 2);
+__decorateClass([
+  (0, import_core3.OneToMany)(() => AuditRelatedEntityChange, "change")
+], AuditChange.prototype, "relatedEntityChanges", 2);
+AuditChange = __decorateClass([
+  (0, import_core3.Entity)(),
+  (0, import_core3.Index)({ properties: ["entityType", "entityId"] })
+], AuditChange);
+
+// ../../packages/mikroorm/src/utils/authentication-context.ts
+var import_logger = require("@exogee/logger");
+var AuthenticationContextImplementation = class {
+  clear() {
+    this.currentUserLogin = void 0;
+  }
+  set(user) {
+    import_logger.logger.trace(`Setting AuthenticationContext.currentUser to ${user}`);
+    this.currentUserLogin = user;
+  }
+  get currentUser() {
+    if (!this.currentUserLogin)
+      throw new Error("Attempted to access AuthenticationContext before it has been set");
+    return this.currentUserLogin;
+  }
+};
+var AuthenticationContext = new AuthenticationContextImplementation();
+
+// ../../packages/mikroorm/src/utils/tracked-entity.ts
+var import_core4 = require("@mikro-orm/core");
+var TrackedEntity = class extends BaseEntity {
+  get relatedTrackedEntities() {
+    return void 0;
+  }
+};
+__decorateClass([
+  (0, import_core4.PrimaryKey)({ type: import_core4.BigIntType })
+], TrackedEntity.prototype, "id", 2);
+
+// ../../packages/mikroorm/src/utils/untracked-property.ts
+var import_reflect_metadata = require("reflect-metadata");
+var untrackedPropertyMetadataKey = Symbol("UntrackedProperty");
+function isUntrackedProperty(target, propertyKey) {
+  return Reflect.getMetadata(untrackedPropertyMetadataKey, target, propertyKey);
+}
+
+// ../../packages/mikroorm/src/utils/change-tracker.ts
+var ChangeTracker = class {
+  async afterFlush({ uow, em }) {
+    const changesets = uow.getChangeSets().filter((cs) => cs.entity instanceof TrackedEntity);
+    const trx = em.getTransactionContext();
+    for (const cs of changesets) {
+      let change;
+      const data = dataForChangeSet(cs);
+      if (data || cs.type === import_core5.ChangeSetType.DELETE) {
+        const changeData = {
+          type: cs.type,
+          entityId: cs.entity.id,
+          entityType: cs.name,
+          createdAt: new Date(),
+          createdBy: AuthenticationContext.currentUser,
+          data
+        };
+        change = await em.getDriver().nativeInsert(AuditChange.name, changeData, trx);
+      }
+      const entity = cs.entity;
+      const relatedEntities = entity.relatedTrackedEntities;
+      if (relatedEntities) {
+        for (const re of relatedEntities) {
+          const relatedEntityData = {
+            change: change == null ? void 0 : change.insertId,
+            relatedEntityId: re.id,
+            relatedEntityType: re.entityType
+          };
+          await em.getDriver().nativeInsert(AuditRelatedEntityChange.name, relatedEntityData, trx);
+        }
+      }
+    }
+  }
+};
+ChangeTracker = __decorateClass([
+  (0, import_core5.Subscriber)()
+], ChangeTracker);
+var dataForChangeSet = (cs) => {
+  if (cs.payload && cs.type !== import_core5.ChangeSetType.DELETE) {
+    const entries = Object.entries(cs.payload).filter(([k]) => !isUntrackedProperty(cs.entity, k)).map(([k]) => processPayloadEntry(k, cs.type, cs.entity, cs.originalEntity));
+    const id = cs.type === import_core5.ChangeSetType.CREATE ? { to: cs.entity.id } : void 0;
+    if (entries.length || id)
+      return { ...Object.fromEntries(entries), id };
+  }
+  return void 0;
+};
+var processPayloadEntry = (key, changeSetType, updatedEntity, originalEntity) => {
+  let from = originalEntity ? originalEntity[key] : null;
+  if (!from && changeSetType === import_core5.ChangeSetType.CREATE)
+    from = void 0;
+  let to = updatedEntity[key] ?? null;
+  if (import_core5.Reference.isReference(to)) {
+    const relatedToEntity = to;
+    if (from) {
+      const id = import_core5.Reference.isReference(from) ? from.getProperty("id") : from;
+      from = {
+        reference: {
+          type: relatedToEntity.constructor.name,
+          id
+        }
+      };
+    }
+    to = {
+      reference: {
+        type: relatedToEntity.constructor.name,
+        id: relatedToEntity.unwrap().id
+      }
+    };
+  }
+  return [key, { from, to }];
+};
+
+// ../../packages/mikroorm/src/database.ts
+var import_core6 = require("@mikro-orm/core");
+var import_postgresql = require("@mikro-orm/postgresql");
+var import_logger2 = require("@exogee/logger");
+var FakeEntity = class {
+};
+FakeEntity = __decorateClass([
+  (0, import_core6.Entity)()
+], FakeEntity);
+var IsolationLevel = /* @__PURE__ */ ((IsolationLevel2) => {
+  IsolationLevel2["SERIALIZABLE"] = "SERIALIZABLE";
+  IsolationLevel2["REPEATABLE_READ"] = "REPEATABLE READ";
+  IsolationLevel2["READ_COMMITTED"] = "READ COMMITTED";
+  IsolationLevel2["READ_UNCOMMITTED"] = "READ UNCOMMITTED";
+  return IsolationLevel2;
+})(IsolationLevel || {});
+var NumericIsolationLevels = {
+  ["SERIALIZABLE" /* SERIALIZABLE */]: 4,
+  ["REPEATABLE READ" /* REPEATABLE_READ */]: 3,
+  ["READ COMMITTED" /* READ_COMMITTED */]: 2,
+  ["READ UNCOMMITTED" /* READ_UNCOMMITTED */]: 1
+};
+var DatabaseImplementation = class {
+  constructor() {
+    this.getConnectionInfo = async (connectionOptions) => {
+      import_logger2.logger.trace("Database::getConnectionInfo() - Enter");
+      const defaults = {
+        host: "localhost",
+        port: 5432,
+        dbName: "graphweaver"
+      };
+      const environmentOverrides = {
+        host: process.env.DATABASE_HOST,
+        port: process.env.DATABASE_PORT ? parseInt(process.env.DATABASE_PORT) : void 0,
+        user: process.env.DATABASE_USERNAME,
+        password: process.env.DATABASE_PASSWORD,
+        dbName: process.env.DATABASE_NAME
+      };
+      const filterUndefined = (obj) => {
+        if (!obj)
+          return {};
+        for (const key of Object.keys(obj)) {
+          if (obj[key] === void 0)
+            delete obj[key];
+        }
+        return obj;
+      };
+      return {
+        ...defaults,
+        ...filterUndefined(environmentOverrides),
+        ...filterUndefined(connectionOptions == null ? void 0 : connectionOptions.overrides)
+      };
+    };
+    this.getRepository = (entityName) => this.em.getRepository(entityName);
+    this.connect = async (connectionOptions) => {
+      var _a;
+      import_logger2.logger.trace("Database::connect() - Enter");
+      if (this.cachedOrm) {
+        import_logger2.logger.trace("Returning cached ORM");
+        return this.cachedOrm;
+      }
+      import_logger2.logger.trace("Creating new ORM");
+      import_logger2.logger.trace("Getting connection info");
+      const params = await this.getConnectionInfo(connectionOptions);
+      import_logger2.logger.trace("Initialising ORM");
+      import_logger2.logger.trace(`${(_a = params.entities) == null ? void 0 : _a.length}x entities`);
+      const orm = await import_core6.MikroORM.init({
+        driver: import_postgresql.PostgreSqlDriver,
+        ...params,
+        implicitTransactions: false,
+        metadataProvider: import_core6.ReflectMetadataProvider,
+        discovery: { disableDynamicFileAccess: true },
+        allowGlobalContext: true,
+        pool: {
+          min: 1,
+          max: 1
+        }
+      });
+      import_logger2.logger.trace("Creating connection to %s on %s", params.dbName, params.host);
+      await orm.connect();
+      import_logger2.logger.trace("Caching connection");
+      this.cachedOrm = orm;
+      return orm;
+    };
+    this.close = async () => {
+      import_logger2.logger.trace("Closing database connection");
+      await this.orm.close();
+      delete this.cachedOrm;
+    };
+  }
+  get orm() {
+    if (!this.cachedOrm) {
+      const error = new Error("Tried to get the ORM before it was connected.");
+      import_logger2.logger.error(error);
+      throw error;
+    }
+    return this.cachedOrm;
+  }
+  get em() {
+    return this.transactionalEm || this.orm.em;
+  }
+  async transactional(callback, isolationLevel = "READ COMMITTED" /* READ_COMMITTED */) {
+    import_logger2.logger.trace("Database::transactional() enter");
+    if (this.transactionInProgressIsolationLevel && NumericIsolationLevels[this.transactionInProgressIsolationLevel] < NumericIsolationLevels[isolationLevel]) {
+      const error = new Error(
+        `Transaction in progress is ${this.transactionInProgressIsolationLevel} isolation level, but ${isolationLevel} was requested, which is more restrictive. Since we can't upgrade, this is an error.`
+      );
+      import_logger2.logger.error(error);
+      throw error;
+    }
+    if (this.transactionalEm) {
+      import_logger2.logger.trace(
+        "Transaction already in progress with sufficient isolation, proceeding without new transaction."
+      );
+      return callback();
+    } else {
+      import_logger2.logger.trace("Starting transaction");
+      return this.em.transactional(async (em) => {
+        this.transactionalEm = em;
+        this.transactionInProgressIsolationLevel = isolationLevel;
+        await em.execute(`SET TRANSACTION ISOLATION LEVEL ${isolationLevel}`);
+        let result;
+        try {
+          result = await callback();
+        } finally {
+          delete this.transactionalEm;
+          delete this.transactionInProgressIsolationLevel;
+        }
+        return result;
+      });
+    }
+  }
+  isolatedTest(test) {
+    return async () => {
+      try {
+        await this.transactional(async () => {
+          await test();
+          throw new Error("Rollback transaction for test");
+        }, "SERIALIZABLE" /* SERIALIZABLE */);
+      } catch (error) {
+        if (error.message !== "Rollback transaction for test") {
+          throw error;
+        }
+      }
+    };
+  }
+  get rawConnection() {
+    return this.em.getDriver().getConnection();
+  }
+};
+var Database = new DatabaseImplementation();
+var checkDatabase = async () => {
+  await Database.connect();
+  const rows = await Database.rawConnection.execute('select 1 = 1 as "ok";');
+  return rows[0].ok;
+};
+var getDbSchema = async () => {
+  await Database.connect();
+  const result = (await Database.orm.getSchemaGenerator().generate()).replace("set names 'utf8';\n", "").replace("set session_replication_role = 'replica';\n", "").replace("set session_replication_role = 'origin';\n", "");
+  await Database.close();
+  return result;
+};
+var clearDatabaseContext = async (req, res, next, connectionOptions) => {
+  await Database.connect(connectionOptions);
+  Database.em.clear();
+  return next ? next() : void 0;
+};
+
+// ../../packages/mikroorm/src/base-resolver/assign.ts
+var assign = async (entity, data, options, visited = /* @__PURE__ */ new Set()) => {
+  if (visited.has(entity))
+    return entity;
+  visited.add(entity);
+  const metadata = (0, import_core7.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_core7.ReferenceType.MANY_TO_MANY || (propertyMetadata == null ? void 0 : propertyMetadata.reference) === import_core7.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_core7.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 = Database.em.getUnitOfWork().getById(propertyMetadata.type, subvalue.id);
+          if (!entity2) {
+            if (Object.keys(subvalue).length === 1) {
+              entity2 = Database.em.getReference(propertyMetadata.type, subvalue.id);
+            } else {
+              import_logger3.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 = await Database.em.findOne(propertyMetadata.type, {
+                id: subvalue.id
+              }) ?? 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_core7.ReferenceType.MANY_TO_ONE || (propertyMetadata == null ? void 0 : propertyMetadata.reference) === import_core7.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] = Database.em.getReference(
+            propertyMetadata.type,
+            value.id
+          );
+        } else {
+          if (entityPropertyValue && !import_core7.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_core7.Reference.create(newEntity);
+        }
+      }
+    } else {
+      entity[property] = value;
+    }
+  }
+  return entity;
+};
+var createOrAssignEntity = ({
+  entity,
+  entityType,
+  data,
+  options,
+  visited
+}) => {
+  const create = (options == null ? void 0 : options.create) ?? true;
+  const update = (options == null ? void 0 : options.update) ?? 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 = Database.em.create(entityType, {});
+    return assign(entity2, data, options, visited);
+  }
+};
+
+// ../../packages/mikroorm/src/base-resolver/provider.ts
+var objectOperations = /* @__PURE__ */ new Set(["_and", "_or", "_not"]);
+var mikroObjectOperations = /* @__PURE__ */ new Set(["$and", "$or", "$not"]);
+var nonJoinKeys = /* @__PURE__ */ new Set([
+  "$and",
+  "$gt",
+  "$gte",
+  "$in",
+  "$lt",
+  "$lte",
+  "$ne",
+  "$nin",
+  "$not",
+  "$or",
+  "$like",
+  "$ilike",
+  "$null",
+  "$notnull",
+  "id"
+]);
+var appendPath = (path, newPath) => path.length ? `${path}.${newPath}` : newPath;
+var visitPathForPopulate = (entityName, updateArgBranch, populateBranch = "") => {
+  var _a, _b, _c, _d;
+  const { properties } = Database.em.getMetadata().get(entityName);
+  const collectedPaths = populateBranch ? /* @__PURE__ */ new Set([populateBranch]) : /* @__PURE__ */ new Set([]);
+  for (const [key, value] of Object.entries(updateArgBranch ?? {})) {
+    if (((_a = properties[key]) == null ? void 0 : _a.reference) === import_core10.ReferenceType.ONE_TO_ONE || ((_b = properties[key]) == null ? void 0 : _b.reference) === import_core10.ReferenceType.ONE_TO_MANY || ((_c = properties[key]) == null ? void 0 : _c.reference) === import_core10.ReferenceType.MANY_TO_ONE || ((_d = properties[key]) == null ? void 0 : _d.reference) === import_core10.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;
+};
+var 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;
+};
+var mapAndAssignKeys = (result, entityType, inputArgs) => {
+  const cleanInput = JSON.parse(JSON.stringify(inputArgs));
+  return assign(result, cleanInput);
+};
+var MikroBackendProvider = class {
+  constructor(mikroType) {
+    this.backendId = "mikro-orm";
+    this.supportsInFilter = true;
+    this.getRepository = () => {
+      const repository = 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") => {
+        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) ? (joinKeysUsed.get(key) ?? 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_logger4.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_core10.QueryFlag.DISTINCT);
+    const driver = Database.em.getDriver();
+    const meta = 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_logger4.logger.trace(`find ${this.entityType.name} result: ${result.length} rows`);
+    return result;
+  }
+  async findOne(id) {
+    import_logger4.logger.trace(`Running findOne ${this.entityType.name} with ID ${id}`);
+    const result = await Database.em.findOne(this.entityType, id);
+    import_logger4.logger.trace(`findOne ${this.entityType.name} result`, { result });
+    return result;
+  }
+  async findByRelatedId(entity, relatedField, relatedFieldIds, filter) {
+    const queryFilter = {
+      $and: [{ [relatedField]: { $in: relatedFieldIds } }, ...[filter ?? []]]
+    };
+    const populate = [relatedField];
+    const result = await Database.em.find(entity, queryFilter, { populate });
+    return result;
+  }
+  async updateOne(id, updateArgs) {
+    import_logger4.logger.trace(`Running update ${this.entityType.name} with args`, {
+      id,
+      updateArgs: JSON.stringify(updateArgs)
+    });
+    const entity = await 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 Database.em.lock(entity, import_core10.LockMode.OPTIMISTIC, updateArgs.version);
+        delete updateArgs.version;
+      } catch (err) {
+        throw new OptimisticLockError(err == null ? void 0 : err.message, { entity });
+      }
+    }
+    await mapAndAssignKeys(entity, this.entityType, updateArgs);
+    await this.getRepository().persistAndFlush(entity);
+    import_logger4.logger.trace(`update ${this.entityType.name} entity`, entity);
+    return entity;
+  }
+  async updateMany(updateItems) {
+    import_logger4.logger.trace(`Running update many ${this.entityType.name} with args`, {
+      updateItems: JSON.stringify(updateItems)
+    });
+    const entities = await 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 Database.em.findOneOrFail(this.entityType, item.id, {
+            populate: [...visitPathForPopulate(this.entityType.name, item)]
+          });
+          await mapAndAssignKeys(entity, this.entityType, item);
+          Database.em.persist(entity);
+          return entity;
+        })
+      );
+    });
+    import_logger4.logger.trace(`updated ${this.entityType.name} items `, entities);
+    return entities;
+  }
+  async createOrUpdateMany(items) {
+    import_logger4.logger.trace(`Running create or update many for ${this.entityType.name} with args`, {
+      items: JSON.stringify(items)
+    });
+    const entities = await Database.transactional(async () => {
+      return Promise.all(
+        items.map(async (item) => {
+          let entity;
+          const { id } = item;
+          if (id) {
+            entity = await Database.em.findOneOrFail(this.entityType, id, {
+              populate: [...visitPathForPopulate(this.entityType.name, item)]
+            });
+            import_logger4.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_logger4.logger.trace(`Running create on ${this.entityType.name} with item`, {
+              item: JSON.stringify(item)
+            });
+          }
+          Database.em.persist(entity);
+          return entity;
+        })
+      );
+    });
+    import_logger4.logger.trace(`created or updated ${this.entityType.name} items `, entities);
+    return entities;
+  }
+  async createOne(createArgs) {
+    import_logger4.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_logger4.logger.trace(`create ${this.entityType.name} result`, entity);
+    return entity;
+  }
+  async createMany(createItems) {
+    import_logger4.logger.trace(`Running create ${this.entityType.name} with args`, {
+      createArgs: JSON.stringify(createItems)
+    });
+    const entities = await Database.transactional(async () => {
+      return Promise.all(
+        createItems.map(async (item) => {
+          const entity = new this.entityType();
+          await mapAndAssignKeys(entity, this.entityType, item);
+          Database.em.persist(entity);
+          return entity;
+        })
+      );
+    });
+    import_logger4.logger.trace(`created ${this.entityType.name} items `, entities);
+    return entities;
+  }
+  async deleteOne(id) {
+    import_logger4.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_logger4.logger.trace(`delete ${this.entityType.name} result: deleted ${deletedRows} row(s)`);
+    return deletedRows === 1;
+  }
+  async deleteMany(ids) {
+    import_logger4.logger.trace(`Running delete ${this.entityType.name} with ids ${ids}`);
+    const deletedRows = await 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_logger4.logger.trace(`delete ${this.entityType.name} result: deleted ${deletedRows} row(s)`);
+    return deletedRows === ids.length;
+  }
+  getRelatedEntityId(entity, relatedIdField) {
+    if (typeof entity.unwrap !== "function") {
+      throw new Error("Could not unwrap related entity");
+    }
+    return entity.unwrap().id;
+  }
+  isCollection(entity) {
+    return import_core10.Utils.isCollection(entity);
+  }
+};
+
+// ../../packages/mikroorm/src/types/date-type.ts
+var import_core8 = require("@mikro-orm/core");
+var DatePattern = /^\d{4}-\d{1,2}-\d{1,2}$/;
+var DateType = class extends import_core8.Type {
+  convertToDatabaseValue(value, platform) {
+    if (!value)
+      return value;
+    if (typeof value === "string") {
+      const [date] = value.split("T");
+      const [year, month, day] = date.split("-");
+      return new Date(`${year}-${month}-${day}T00:00:00Z`);
+    }
+    throw import_core8.ValidationError.invalidType(DateType, value, "JS");
+  }
+  convertToJSValue(value, platform) {
+    if (!value)
+      return value;
+    if (typeof value === "string" && DatePattern.test(value)) {
+      return value;
+    }
+    throw import_core8.ValidationError.invalidType(DateType, value, "database");
+  }
+  getColumnType(prop, platform) {
+    return "date";
+  }
+  toJSON(value, platform) {
+    if (!value)
+      return value;
+    if (value instanceof Date) {
+      return `${value.getFullYear()}-${value.getMonth() + 1}-${value.getDate()}`;
+    } else if (typeof value === "string") {
+      return value;
+    }
+    throw import_core8.ValidationError.invalidType(DateType, value, "JS");
+  }
+};
+
+// ../../packages/mikroorm/src/types/time-type.ts
+var import_core9 = require("@mikro-orm/core");
+var TimePattern = /^\d{2}:\d{2}:\d{2}$/;
+var Time = class {
+  constructor(hour = 0, minute = 0, second = 0) {
+    this.hour = hour;
+    this.minute = minute;
+    this.second = second;
+    if (hour > 23 || hour < 0)
+      throw new Error(`Invalid time '${hour}:${minute}:${second}`);
+    if (minute > 59 || minute < 0)
+      throw new Error(`Invalid time '${hour}:${minute}:${second}`);
+    if (second > 59 || second < 0)
+      throw new Error(`Invalid time '${hour}:${minute}:${second}`);
+  }
+  toString() {
+    return `${this.hour.toString().padStart(2, "0")}:${this.minute.toString().padStart(2, "0")}:${this.second.toString().padStart(2, "0")}`;
+  }
+};
+var TimeType = class extends import_core9.Type {
+  convertToDatabaseValue(value, platform) {
+    if (!value)
+      return value;
+    if (value instanceof Time)
+      return value;
+    throw import_core9.ValidationError.invalidType(TimeType, value, "JS");
+  }
+  convertToJSValue(value, platform) {
+    if (!value)
+      return value;
+    if (typeof value === "string" && TimePattern.test(value)) {
+      const [hour, minute, second] = value.split(":");
+      return new Time(+hour, +minute, +second);
+    }
+    throw import_core9.ValidationError.invalidType(TimeType, value, "database");
+  }
+  getColumnType(prop, platform) {
+    return "time";
+  }
+  toJSON(value, platform) {
+    if (!value)
+      return value;
+    if (value instanceof Time)
+      return Time.toString();
+    throw import_core9.ValidationError.invalidType(TimeType, value, "JS");
+  }
+};
+
+// ../../packages/mikroorm/src/index.ts
+var import_core10 = require("@mikro-orm/core");
+var import_postgresql2 = require("@mikro-orm/postgresql");
+dotenv.config({
+  path: `.env.${(process.env.NODE_ENV || "development").toLowerCase()}`
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuditChange,
+  AuditRelatedEntityChange,
+  AuthenticationContext,
+  BaseEntity,
+  ChangeSetType,
+  Collection,
+  Database,
+  DatabaseObjectNotFoundException,
+  DateType,
+  EntityManager,
+  EntityRepository,
+  IsolationLevel,
+  LockMode,
+  MikroBackendProvider,
+  PrimaryKeyType,
+  QueryFlag,
+  QueryOrder,
+  Reference,
+  ReferenceType,
+  SqlEntityManager,
+  SqlEntityRepository,
+  Subscriber,
+  Time,
+  TimeType,
+  UniqueConstraintViolationException,
+  Utils,
+  checkDatabase,
+  clearDatabaseContext,
+  getDbSchema,
+  gqlToMikro,
+  mapAndAssignKeys,
+  visitPathForPopulate,
+  wrap
+});
+//# sourceMappingURL=index.js.map