@treatwell/moleculer-essentials 1.0.0

package/dist/mixins/database.mixin.cjs

@@ -0,0 +1,1673 @@
+'use strict';
+
+var v4 = require('zod/v4');
+var index = require('../index-rZl77S1z.cjs');
+var moleculer = require('moleculer');
+var lodash = require('lodash');
+var mongodb = require('mongodb');
+var index$1 = require('../index-82e1CXJX.cjs');
+var mixins_globalStore_mixin = require('./global-store.mixin.cjs');
+require('bson');
+require('date-fns');
+require('zod');
+
+const { MoleculerClientError } = moleculer.Errors;
+class EntityNotFoundError extends MoleculerClientError {
+  constructor(id) {
+    super("Entity not found", 404, "ENTITY_NOT_FOUND", { id });
+  }
+}
+
+function removeMongoId(schema, refName) {
+  return index.omitFields(schema, ["_id"], refName);
+}
+function optionalMongoId(schema, refName) {
+  return index.optionalFields(schema, ["_id"], refName);
+}
+function optimizeQuery(query) {
+  const { $or, ...rest } = query;
+  if (!Array.isArray($or) || $or.length === 0) {
+    return query;
+  }
+  return {
+    $or: $or.map((predicate) => ({ ...predicate, ...rest }))
+  };
+}
+
+var QueryOp = /* @__PURE__ */ ((QueryOp2) => {
+  QueryOp2["GT"] = "$gt";
+  QueryOp2["GTE"] = "$gte";
+  QueryOp2["LT"] = "$lt";
+  QueryOp2["LTE"] = "$lte";
+  QueryOp2["IN"] = "$in";
+  QueryOp2["EQ"] = "$eq";
+  QueryOp2["NE"] = "$ne";
+  return QueryOp2;
+})(QueryOp || {});
+
+class AjvActionSchemaFactory {
+  constructor(opts) {
+    this.opts = opts;
+    const { schema, tenantField } = opts;
+    if (schema) {
+      if (tenantField) {
+        this.tenantFieldType = schema.properties[tenantField];
+      }
+      this._idFieldType = schema.properties._id;
+    }
+  }
+  tenantFieldType;
+  _idFieldType;
+  hasIdField() {
+    return !!this._idFieldType;
+  }
+  hasTenantIdField() {
+    return !!this.tenantFieldType;
+  }
+  createSchemaWithDbFields() {
+    const { timestamps, schema, schemaName } = this.opts;
+    if (!schema) {
+      throw new Error("Schema is not defined");
+    }
+    const requiredSet = new Set(schema.required);
+    requiredSet.add("_id");
+    if (timestamps) {
+      requiredSet.add("createdAt");
+      requiredSet.add("updatedAt");
+    }
+    return {
+      ...schema,
+      [index.SCHEMA_REF_NAME]: schemaName ? `Full${schemaName}` : void 0,
+      required: [...requiredSet.values()]
+    };
+  }
+  createFindParams() {
+    const { tenantField, softDelete } = this.opts;
+    const { tenantFieldType } = this;
+    const additionalProps = {};
+    const required = [];
+    if (tenantField && tenantFieldType) {
+      required.push(tenantField);
+      additionalProps[tenantField] = tenantFieldType;
+    }
+    if (softDelete) {
+      additionalProps.scope = {
+        type: "string",
+        enum: ["include-deleted", "only-deleted", "no-deleted"]
+      };
+    }
+    return {
+      type: "object",
+      additionalProperties: false,
+      required,
+      properties: {
+        query: { type: "object", additionalProperties: true, required: [] },
+        fields: { type: "array", items: { type: "string" } },
+        sort: { type: "array", items: { type: "string" } },
+        limit: { type: "integer", minimum: 0 },
+        offset: { type: "integer", minimum: 0 },
+        collation: { type: "object" },
+        ...additionalProps
+      }
+    };
+  }
+  createGetParams(params) {
+    const { _idFieldType, tenantFieldType } = this;
+    const { tenantField, softDelete } = this.opts;
+    const { allowFields } = params;
+    const additionalProps = {};
+    const required = ["_id"];
+    if (tenantField && tenantFieldType) {
+      required.push(tenantField);
+      additionalProps[tenantField] = tenantFieldType;
+    }
+    if (softDelete) {
+      additionalProps.scope = {
+        type: "string",
+        enum: ["include-deleted", "only-deleted", "no-deleted"]
+      };
+    }
+    if (allowFields) {
+      additionalProps.fields = { type: "array", items: { type: "string" } };
+    }
+    return {
+      type: "object",
+      additionalProperties: false,
+      required,
+      properties: {
+        _id: _idFieldType || index.OBJECTID_TYPE,
+        ...additionalProps
+      }
+    };
+  }
+  createCountParams(params) {
+    const { tenantFieldType } = this;
+    const { tenantField, softDelete } = this.opts;
+    const { queryType } = params;
+    const properties = {};
+    const required = [];
+    if (tenantField && tenantFieldType) {
+      required.push(tenantField);
+      properties[tenantField] = tenantFieldType;
+    }
+    if (softDelete) {
+      properties.scope = {
+        type: "string",
+        enum: ["include-deleted", "only-deleted", "no-deleted"]
+      };
+    }
+    if (queryType === "stringified") {
+      properties.sQuery = { type: "string" };
+    } else if (queryType === "object") {
+      properties.query = { type: "object", additionalProperties: true };
+    }
+    return {
+      type: "object",
+      additionalProperties: false,
+      required,
+      properties
+    };
+  }
+  createListParams(params) {
+    const { tenantField, softDelete } = this.opts;
+    const { tenantFieldType } = this;
+    const { queryType, maxPageSize } = params;
+    const additionalProperties = {};
+    const required = [];
+    if (tenantField && tenantFieldType) {
+      required.push(tenantField);
+      additionalProperties[tenantField] = tenantFieldType;
+    }
+    if (softDelete) {
+      additionalProperties.scope = {
+        type: "string",
+        enum: ["include-deleted", "only-deleted", "no-deleted"]
+      };
+    }
+    if (queryType === "stringified") {
+      additionalProperties.sQuery = { type: "string" };
+    } else if (queryType === "object") {
+      additionalProperties.query = {
+        type: "object",
+        additionalProperties: true
+      };
+    }
+    return {
+      type: "object",
+      additionalProperties: false,
+      required,
+      properties: {
+        page: { type: "integer", minimum: 0 },
+        pageSize: {
+          type: "integer",
+          minimum: 1,
+          maximum: maxPageSize || 100
+        },
+        sort: {
+          type: "array",
+          items: { type: "string" },
+          [index.COERCE_ARRAY_ATTRIBUTE]: true
+        },
+        ...additionalProperties
+      }
+    };
+  }
+  createListResponse() {
+    return {
+      type: "object",
+      required: ["rows", "page", "pageSize", "total", "totalPages"],
+      additionalProperties: false,
+      properties: {
+        rows: { type: "array", items: this.createSchemaWithDbFields() },
+        page: { type: "integer", minimum: 0 },
+        pageSize: { type: "integer", minimum: 1 },
+        total: { type: "integer", minimum: 0 },
+        totalPages: { type: "integer", minimum: 0 }
+      }
+    };
+  }
+  createCreateParams(params) {
+    const { schema } = this.opts;
+    const { allowClientId } = params;
+    if (!schema) {
+      throw new Error("Schema is not defined");
+    }
+    if (allowClientId) {
+      return schema;
+    }
+    return removeMongoId(schema);
+  }
+  createUpdateParams() {
+    const { tenantField, schema } = this.opts;
+    if (!schema) {
+      throw new Error("Schema is not defined");
+    }
+    const required = ["_id"];
+    if (tenantField) {
+      required.push(tenantField);
+    }
+    return { ...schema, required };
+  }
+  createRemoveParams() {
+    const { tenantFieldType, _idFieldType } = this;
+    const { tenantField } = this.opts;
+    const required = ["_id"];
+    const additionalProps = {};
+    if (tenantField && tenantFieldType) {
+      required.push(tenantField);
+      additionalProps[tenantField] = tenantFieldType;
+    }
+    return {
+      type: "object",
+      additionalProperties: false,
+      required,
+      properties: {
+        _id: _idFieldType || index.OBJECTID_TYPE,
+        ...additionalProps
+      }
+    };
+  }
+}
+function addQueryOps(schema, queryOps) {
+  const ops = Object.fromEntries(queryOps.map((op) => [op, true]));
+  return {
+    oneOf: [
+      schema,
+      {
+        type: "object",
+        additionalProperties: false,
+        required: [],
+        properties: {
+          ...ops[QueryOp.GT] ? { $gt: schema } : {},
+          ...ops[QueryOp.GTE] ? { $gte: schema } : {},
+          ...ops[QueryOp.LT] ? { $lt: schema } : {},
+          ...ops[QueryOp.LTE] ? { $lte: schema } : {},
+          ...ops[QueryOp.IN] ? { $in: { type: "array", items: schema } } : {},
+          ...ops[QueryOp.EQ] ? { $eq: schema } : {},
+          ...ops[QueryOp.NE] ? { $ne: schema } : {}
+        }
+      }
+    ]
+  };
+}
+
+function parseStringifiedQuery(sQuery) {
+  if (!sQuery) {
+    return {};
+  }
+  let query = {};
+  try {
+    query = JSON.parse(sQuery || "{}");
+  } catch {
+    throw new moleculer.Errors.ValidationError("Invalid query format");
+  }
+  return query;
+}
+function parseAndValidateQuery(validator, schema, sQuery) {
+  if (!schema) {
+    return {};
+  }
+  let query = parseStringifiedQuery(sQuery);
+  if (schema instanceof v4.ZodType) {
+    query = validator.validate(query, schema);
+  } else {
+    validator.validate(query, schema);
+  }
+  return query;
+}
+
+const ScopeSchema = v4.z.enum(["include-deleted", "only-deleted", "no-deleted"]);
+class ZodActionSchemaFactory {
+  constructor(opts) {
+    this.opts = opts;
+    const { schema, tenantField } = opts;
+    if (schema) {
+      if (!(schema instanceof v4.ZodObject)) {
+        throw new Error("Schema must be a ZodObject");
+      }
+      if (tenantField) {
+        this.tenantFieldType = schema.shape[tenantField];
+      }
+      this._idFieldType = schema.shape._id;
+    }
+  }
+  tenantFieldType;
+  _idFieldType;
+  schemaWithDbFields;
+  hasIdField() {
+    return !!this._idFieldType;
+  }
+  hasTenantIdField() {
+    return !!this.tenantFieldType;
+  }
+  createSchemaWithDbFields() {
+    if (this.schemaWithDbFields) {
+      return this.schemaWithDbFields;
+    }
+    const { timestamps, schema, schemaName } = this.opts;
+    if (!schema || !(schema instanceof v4.ZodObject)) {
+      throw new Error("Schema is not a ZodObject");
+    }
+    let res = schema.required({ _id: true });
+    if (timestamps) {
+      res = res.required({ createdAt: true, updatedAt: true });
+    }
+    if (schemaName) {
+      res = res.meta({ id: `Full${schemaName}` });
+    }
+    this.schemaWithDbFields = res;
+    return res;
+  }
+  createFindParams() {
+    const { tenantField, softDelete } = this.opts;
+    const { tenantFieldType } = this;
+    const shape = {
+      query: v4.z.looseObject({}).optional(),
+      fields: v4.z.array(v4.z.string()).optional(),
+      sort: v4.z.array(v4.z.string()).optional(),
+      limit: v4.z.uint32().optional(),
+      offset: v4.z.uint32().optional(),
+      collation: v4.z.looseObject({}).optional()
+    };
+    if (tenantField && tenantFieldType) {
+      shape[tenantField] = tenantFieldType;
+    }
+    if (softDelete) {
+      shape.scope = ScopeSchema.optional();
+    }
+    return v4.z.object(shape);
+  }
+  createGetParams(params) {
+    const { _idFieldType, tenantFieldType } = this;
+    const { tenantField, softDelete } = this.opts;
+    const { allowFields } = params;
+    const shape = {
+      _id: _idFieldType || index.zodObjectId
+    };
+    if (tenantField && tenantFieldType) {
+      shape[tenantField] = tenantFieldType;
+    }
+    if (softDelete) {
+      shape.scope = ScopeSchema.optional();
+    }
+    if (allowFields) {
+      shape.fields = v4.z.array(v4.z.string()).optional();
+    }
+    return v4.z.object(shape);
+  }
+  createCountParams(params) {
+    const { tenantFieldType } = this;
+    const { tenantField, softDelete } = this.opts;
+    const { queryType } = params;
+    const shape = {};
+    if (queryType === "stringified") {
+      shape.sQuery = v4.z.string().optional();
+    } else if (queryType === "object") {
+      shape.query = v4.z.looseObject({}).optional();
+    }
+    if (tenantField && tenantFieldType) {
+      shape[tenantField] = tenantFieldType;
+    }
+    if (softDelete) {
+      shape.scope = ScopeSchema.optional();
+    }
+    return v4.z.object(shape);
+  }
+  createListParams(params) {
+    const { tenantField, softDelete } = this.opts;
+    const { tenantFieldType } = this;
+    const { queryType, maxPageSize } = params;
+    const shape = {
+      page: v4.z.coerce.number().int().min(0).optional(),
+      pageSize: v4.z.coerce.number().int().min(1).max(maxPageSize || 100).optional(),
+      sort: index.zodCoerceArray(v4.z.string()).optional()
+    };
+    if (queryType === "stringified") {
+      shape.sQuery = v4.z.string().optional();
+    } else if (queryType === "object") {
+      shape.query = v4.z.looseObject({}).optional();
+    }
+    if (tenantField && tenantFieldType) {
+      shape[tenantField] = tenantFieldType;
+    }
+    if (softDelete) {
+      shape.scope = ScopeSchema.optional();
+    }
+    return v4.z.object(shape);
+  }
+  createListResponse() {
+    return v4.z.strictObject({
+      rows: v4.z.array(this.createSchemaWithDbFields()),
+      page: v4.z.uint32(),
+      pageSize: v4.z.int().min(1),
+      total: v4.z.uint32(),
+      totalPages: v4.z.uint32()
+    });
+  }
+  createCreateParams(params) {
+    const { schema } = this.opts;
+    const { allowClientId } = params;
+    if (!schema || !(schema instanceof v4.ZodObject)) {
+      throw new Error("Schema is not a ZodObject");
+    }
+    if (allowClientId) {
+      return schema;
+    }
+    return schema.omit({ _id: true });
+  }
+  createUpdateParams() {
+    const { tenantField, schema } = this.opts;
+    if (!schema || !(schema instanceof v4.ZodObject)) {
+      throw new Error("Schema is not a ZodObject");
+    }
+    const mask = { _id: true };
+    if (tenantField) {
+      mask[tenantField] = true;
+    }
+    return schema.partial().required(mask);
+  }
+  createRemoveParams() {
+    const { tenantFieldType, _idFieldType } = this;
+    const { tenantField } = this.opts;
+    const shape = {
+      _id: _idFieldType || index.zodObjectId
+    };
+    if (tenantField && tenantFieldType) {
+      shape[tenantField] = tenantFieldType;
+    }
+    return v4.z.object(shape);
+  }
+}
+function addZodQueryOps(fieldValue, queryOps) {
+  const shape = {};
+  for (const op of queryOps) {
+    if (op === QueryOp.IN) {
+      shape.$in = v4.z.array(fieldValue).optional();
+    } else {
+      shape[op] = fieldValue.optional();
+    }
+  }
+  return v4.z.union([fieldValue, v4.z.object(shape)]);
+}
+
+const PUBLISHABLE_ACTIONS = [
+  "get",
+  "count",
+  "list",
+  "create",
+  "update",
+  "remove"
+];
+function createActions(opts) {
+  const actions = {};
+  const factory = opts.actions?.schemaFactory || (opts.actions?.schema instanceof v4.ZodType ? new ZodActionSchemaFactory({
+    schemaName: opts.actions.schemaName,
+    schema: opts.actions.schema,
+    timestamps: opts.timestamps,
+    softDelete: opts.softDelete,
+    tenantField: opts.tenantField
+  }) : new AjvActionSchemaFactory({
+    schemaName: opts.actions?.schemaName,
+    schema: opts.actions?.schema,
+    timestamps: opts.timestamps,
+    softDelete: opts.softDelete,
+    tenantField: opts.tenantField
+  }));
+  for (const action of PUBLISHABLE_ACTIONS) {
+    if (opts.actions?.[action]) {
+      if (!opts.actions.schema) {
+        throw new Error(`Missing schema for action ${action}`);
+      }
+      if (!factory.hasIdField()) {
+        throw new Error(`Missing _id for action ${action}`);
+      }
+      if (opts.tenantField && !factory.hasTenantIdField()) {
+        throw new Error(`Missing ${opts.tenantField} for action ${action}`);
+      }
+    }
+  }
+  const schemaName = opts.actions?.schemaName;
+  if (opts.actions?.find) {
+    actions.find = {
+      visibility: opts.actions.find.visibility,
+      params: factory.createFindParams(),
+      async handler(ctx) {
+        const { query, fields, offset, sort, limit, collation } = ctx.params;
+        let params = null;
+        if (opts.tenantField) {
+          params = { [opts.tenantField]: ctx.params[opts.tenantField] };
+        }
+        return this._find(query || {}, params, {
+          fields,
+          sort,
+          limit,
+          skip: offset,
+          collation,
+          // @ts-expect-error Scope is not always here and TS doesn't like it
+          scope: ctx.params.scope
+        });
+      }
+    };
+  }
+  if (opts.actions?.findStream) {
+    actions.findStream = {
+      visibility: opts.actions.findStream.visibility,
+      params: factory.createFindParams(),
+      async handler(ctx) {
+        const { query, fields, offset, sort, limit, collation } = ctx.params;
+        let params = null;
+        if (opts.tenantField) {
+          params = { [opts.tenantField]: ctx.params[opts.tenantField] };
+        }
+        return this._findStream(query || {}, params, {
+          fields,
+          sort,
+          limit,
+          skip: offset,
+          collation,
+          // @ts-expect-error Scope is not always here and TS doesn't like it
+          scope: ctx.params.scope
+        });
+      }
+    };
+  }
+  if (opts.actions?.getInternal) {
+    actions.getInternal = {
+      visibility: opts.actions.getInternal.visibility,
+      params: factory.createGetParams({ allowFields: true }),
+      async handler(ctx) {
+        const { fields, _id } = ctx.params;
+        let params = null;
+        if (opts.tenantField) {
+          params = { [opts.tenantField]: ctx.params[opts.tenantField] };
+        }
+        const res = await this._findOne({ _id }, params, {
+          fields,
+          // @ts-expect-error Scope is not always here and TS doesn't like it
+          scope: ctx.params.scope
+        });
+        if (!res) {
+          throw new EntityNotFoundError(_id.toString());
+        }
+        return res;
+      }
+    };
+  }
+  if (opts.actions?.get) {
+    actions.get = {
+      rest: "GET /:_id",
+      openapi: index.createOpenAPIResponses(factory.createSchemaWithDbFields()),
+      visibility: opts.actions.get.visibility,
+      params: factory.createGetParams({ allowFields: false }),
+      async handler(ctx) {
+        const { _id } = ctx.params;
+        let params = null;
+        if (opts.tenantField) {
+          params = { [opts.tenantField]: ctx.params[opts.tenantField] };
+        }
+        const res = await this._findOne({ _id }, params, {
+          // @ts-expect-error Scope is not always here and TS doesn't like it
+          scope: ctx.params.scope
+        });
+        if (!res) {
+          throw new EntityNotFoundError(_id.toString());
+        }
+        return res;
+      }
+    };
+  }
+  if (opts.actions?.countInternal) {
+    actions.countInternal = {
+      visibility: opts.actions.countInternal.visibility,
+      params: factory.createCountParams({ queryType: "object" }),
+      async handler(ctx) {
+        const { query } = ctx.params;
+        let params = null;
+        if (opts.tenantField) {
+          params = { [opts.tenantField]: ctx.params[opts.tenantField] };
+        }
+        return this._countDocuments(query || {}, params, {
+          // @ts-expect-error Scope is not always here and TS doesn't like it
+          scope: ctx.params.scope
+        });
+      }
+    };
+  }
+  if (opts.actions?.count) {
+    actions.count = {
+      rest: "GET /count",
+      openapi: index.createOpenAPIResponses({ type: "integer" }),
+      visibility: opts.actions.count.visibility,
+      params: factory.createCountParams({ queryType: "stringified" }),
+      async handler(ctx) {
+        const { sQuery } = ctx.params;
+        const query = parseAndValidateQuery(
+          this.broker.validator,
+          opts.sQuerySchema,
+          sQuery
+        );
+        let params = null;
+        if (opts.tenantField) {
+          params = { [opts.tenantField]: ctx.params[opts.tenantField] };
+        }
+        return this._countDocuments(query, params, {
+          // @ts-expect-error Scope is not always here and TS doesn't like it
+          scope: ctx.params.scope
+        });
+      }
+    };
+  }
+  if (opts.actions?.list) {
+    actions.list = {
+      rest: "GET /",
+      openapi: index.createOpenAPIResponses(factory.createListResponse()),
+      visibility: opts.actions.list.visibility,
+      params: factory.createListParams({
+        queryType: "stringified",
+        maxPageSize: opts.actions.list.maxPageSize
+      }),
+      async handler(ctx) {
+        const {
+          sQuery,
+          sort = opts.actions?.list?.defaultSort,
+          collation
+        } = ctx.params;
+        const query = parseAndValidateQuery(
+          this.broker.validator,
+          opts.sQuerySchema,
+          sQuery
+        );
+        let params = null;
+        if (opts.tenantField) {
+          params = { [opts.tenantField]: ctx.params[opts.tenantField] };
+        }
+        const page = ctx.params.page || 0;
+        const pageSize = ctx.params.pageSize || opts.actions?.list?.defaultPageSize || 10;
+        const [rows, total] = await Promise.all([
+          this._find(query, params, {
+            limit: pageSize,
+            skip: page * pageSize,
+            sort,
+            // @ts-expect-error Scope is not always here and TS doesn't like it
+            scope: ctx.params.scope,
+            collation
+          }),
+          this._countDocuments(query, params, {
+            // @ts-expect-error Scope is not always here and TS doesn't like it
+            scope: ctx.params.scope,
+            collation
+          })
+        ]);
+        return {
+          rows,
+          page,
+          pageSize,
+          total,
+          totalPages: Math.floor((total + pageSize - 1) / pageSize)
+        };
+      }
+    };
+  }
+  if (opts.actions?.create) {
+    actions.create = {
+      rest: "POST /",
+      openapi: index.createOpenAPIResponses(factory.createSchemaWithDbFields()),
+      visibility: opts.actions.create.visibility,
+      bodySchemaRefName: schemaName && `Create${schemaName}`,
+      params: factory.createCreateParams({
+        allowClientId: opts.actions.create.allowClientId
+      }),
+      handler(ctx) {
+        return this._insertOne(ctx, ctx.params);
+      }
+    };
+  }
+  if (opts.actions?.update) {
+    actions.update = {
+      rest: "PATCH /:_id",
+      openapi: index.createOpenAPIResponses(factory.createSchemaWithDbFields()),
+      visibility: opts.actions.update.visibility,
+      params: factory.createUpdateParams(),
+      handler(ctx) {
+        let params = null;
+        if (opts.tenantField) {
+          params = { [opts.tenantField]: ctx.params[opts.tenantField] };
+        }
+        return this._updateOne(ctx, { _id: ctx.params._id }, params, {
+          $set: ctx.params
+        });
+      }
+    };
+  }
+  if (opts.actions?.remove) {
+    actions.remove = {
+      rest: "DELETE /:_id",
+      openapi: index.createOpenAPIResponses(factory.createSchemaWithDbFields()),
+      visibility: opts.actions.remove.visibility,
+      params: factory.createRemoveParams(),
+      handler(ctx) {
+        let params = null;
+        if (opts.tenantField) {
+          params = { [opts.tenantField]: ctx.params[opts.tenantField] };
+        }
+        return this._deleteOne(ctx, { _id: ctx.params._id }, params);
+      }
+    };
+  }
+  return actions;
+}
+
+function DatabaseConnectionMixin(opts) {
+  const { databaseName, collectionName, createCollectionOptions } = opts;
+  const uri = globalThis.__MONGO_URI__ || opts.uri || process.env.MONGO_URL || process.env.MONGODB_URL || "mongodb://localhost:27017";
+  const dbName = globalThis.__MONGO_DB_NAME__ ? `${globalThis.__MONGO_DB_NAME__}-${databaseName}` : databaseName;
+  const key = uri;
+  return index$1.wrapMixin({
+    mixins: [mixins_globalStore_mixin.GlobalStoreMixin()],
+    methods: {
+      getMongoClient() {
+        return this.mongoClient;
+      },
+      getCollection(options) {
+        return this.getMongoClient().db(dbName).collection(collectionName, options);
+      }
+    },
+    created() {
+      let client = this.getFromStore("mongodb", key);
+      this.logger.debug(
+        "MongoDB mixin starting, loading mongo client from store"
+      );
+      if (!client) {
+        this.logger.info(
+          "Didn't find mongo client in store, creating a new one"
+        );
+        client = new mongodb.MongoClient(uri);
+        this.setClientToStore("mongodb", key, client, async () => {
+          this.logger.debug("Closing mongoDB connection");
+          await client?.close();
+          this.logger.info("MongoDB connection closed");
+        });
+        client.on("error", (err) => this.logger.error("MongoDB error", err));
+      }
+      this.mongoClient = client;
+    },
+    async started() {
+      this.logger.debug("Service connecting to mongoDB");
+      await this.getMongoClient().connect();
+      this.logger.debug("Service connected to mongoDB, creating collection");
+      try {
+        await this.getMongoClient().db(dbName).createCollection(collectionName, createCollectionOptions);
+      } catch (err) {
+        if (err?.code !== 48) {
+          this.logger.error("Error while creating collection", { err });
+        }
+      }
+    },
+    async stopped() {
+      await this.removeServiceFromStore("mongodb", key);
+    }
+  });
+}
+
+const {
+  MONGO_URL = "",
+  MONGODB_URL = "",
+  SYNC_MONGO_INDEX,
+  SYNC_INDEX_AUTO_CREATE,
+  SYNC_INDEX_AUTO_DROP
+} = process.env;
+function getDefaultIndexName(key) {
+  return Object.entries(key).flat(1).join("_");
+}
+function isIndexNameEqual(dbIdx, idx) {
+  const [keys, opts] = idx;
+  return dbIdx.name === (opts?.name || getDefaultIndexName(keys));
+}
+function isIndexEqual(dbIdx, idx) {
+  const [keys, opts] = idx;
+  if (Object.keys(dbIdx.key).length !== Object.keys(keys).length) {
+    return false;
+  }
+  if (Object.entries(dbIdx.key).some(([field, val]) => keys[field] !== val)) {
+    return false;
+  }
+  if (dbIdx.collation || opts?.collation) {
+    if (!dbIdx.collation || !opts?.collation) {
+      return false;
+    }
+    if (!lodash.isMatch(dbIdx.collation, opts.collation)) {
+      return false;
+    }
+  }
+  if (Boolean(dbIdx.sparse) !== Boolean(opts?.sparse)) {
+    return false;
+  }
+  return dbIdx.expireAfterSeconds === opts?.expireAfterSeconds && dbIdx.unique === opts?.unique && lodash.isEqual(dbIdx.partialFilterExpression, opts?.partialFilterExpression);
+}
+function isOnAtlas() {
+  return (MONGO_URL || MONGODB_URL).includes(".mongodb.net");
+}
+function shouldAutoCreateIndexes() {
+  if (SYNC_INDEX_AUTO_CREATE) {
+    return SYNC_INDEX_AUTO_CREATE === "yes";
+  }
+  if (SYNC_MONGO_INDEX) {
+    return SYNC_MONGO_INDEX === "yes";
+  }
+  return !isOnAtlas();
+}
+function shouldAutoDropIndexes() {
+  if (SYNC_INDEX_AUTO_DROP) {
+    return SYNC_INDEX_AUTO_DROP === "yes";
+  }
+  if (SYNC_MONGO_INDEX) {
+    return SYNC_MONGO_INDEX === "yes";
+  }
+  return !isOnAtlas();
+}
+async function getIndexesDifference$1({
+  collection,
+  declaredIdxs
+}) {
+  const dbIdxs = await collection.indexes();
+  const idxsToCreate = declaredIdxs.filter((idx) => !dbIdxs.find((dbIdx) => isIndexNameEqual(dbIdx, idx))).map(([key, opts]) => ({ key, ...opts }));
+  const idxsToUpdate = declaredIdxs.filter(
+    (idx) => dbIdxs.find(
+      (dbIdx) => isIndexNameEqual(dbIdx, idx) && !isIndexEqual(dbIdx, idx)
+    )
+  ).map(([key, opts]) => ({ key, ...opts }));
+  const idxsToDelete = dbIdxs.filter((dbIdx) => dbIdx.name !== "_id_").filter((dbIdx) => !declaredIdxs.find((idx) => isIndexNameEqual(dbIdx, idx)));
+  return {
+    idxsToCreate,
+    idxsToDelete,
+    idxsToUpdate,
+    synced: !(idxsToCreate.length || idxsToUpdate.length || idxsToDelete.length)
+  };
+}
+
+var IndexStatus = /* @__PURE__ */ ((IndexStatus2) => {
+  IndexStatus2["OK"] = "OK";
+  IndexStatus2["MISSING"] = "MISSING";
+  IndexStatus2["OUTDATED"] = "OUTDATED";
+  IndexStatus2["NOT_DECLARED"] = "NOT_DECLARED";
+  return IndexStatus2;
+})(IndexStatus || {});
+
+async function getIndexesDifference(collection, declaredIndexes = [], declaredSearchIndexes = {}) {
+  const states = [];
+  const dbIdxs = await collection.listIndexes().toArray();
+  for (const idx of declaredIndexes) {
+    const dbIdxPos = dbIdxs.findIndex((i) => isIndexNameEqual(i, idx));
+    if (dbIdxPos === -1) {
+      states.push({
+        type: "index",
+        status: IndexStatus.MISSING,
+        declaredIndex: idx
+      });
+    } else {
+      const [dbIdx] = dbIdxs.splice(dbIdxPos, 1);
+      if (!isIndexEqual(dbIdx, idx)) {
+        states.push({
+          type: "index",
+          status: IndexStatus.OUTDATED,
+          index: dbIdx,
+          declaredIndex: idx
+        });
+      } else {
+        states.push({
+          type: "index",
+          status: IndexStatus.OK,
+          index: dbIdx,
+          declaredIndex: idx
+        });
+      }
+    }
+  }
+  for (const index of dbIdxs) {
+    if (index.name !== "_id_") {
+      states.push({ type: "index", status: IndexStatus.NOT_DECLARED, index });
+    }
+  }
+  let searchIndexes;
+  try {
+    searchIndexes = await collection.listSearchIndexes().toArray();
+  } catch {
+    return states;
+  }
+  for (const [name, idx] of Object.entries(declaredSearchIndexes)) {
+    const dbIdxPos = searchIndexes.findIndex((i) => i.name === name);
+    if (dbIdxPos === -1) {
+      states.push({
+        type: "searchIndex",
+        name,
+        status: IndexStatus.MISSING,
+        declaredSearchIndex: idx
+      });
+    } else {
+      const [dbIdx] = searchIndexes.splice(dbIdxPos, 1);
+      if (!lodash.isEqual(dbIdx.latestDefinition, idx)) {
+        states.push({
+          type: "searchIndex",
+          name,
+          status: IndexStatus.OUTDATED,
+          searchIndex: dbIdx.latestDefinition,
+          declaredSearchIndex: idx
+        });
+      } else {
+        states.push({
+          type: "searchIndex",
+          name,
+          status: IndexStatus.OK,
+          searchIndex: dbIdx.latestDefinition,
+          declaredSearchIndex: idx
+        });
+      }
+    }
+  }
+  for (const index of searchIndexes) {
+    states.push({
+      type: "searchIndex",
+      name: index.name,
+      status: IndexStatus.NOT_DECLARED,
+      searchIndex: index.latestDefinition
+    });
+  }
+  return states;
+}
+const DATABASE_INDEXES_MIXIN_SYNC_EVENT = "database-indexes-mixin.sync";
+function DatabaseIndexesMixin(opts) {
+  return index$1.wrapMixin({
+    methods: {
+      async _syncIndexes({
+        dropIndexes,
+        createIndexes
+      }) {
+        if (typeof this.getCollection !== "function") {
+          throw new Error(
+            "getCollection method not found, did you add the DatabaseConnectionMixin?"
+          );
+        }
+        const collection = this.getCollection();
+        const states = await getIndexesDifference(
+          collection,
+          opts.indexes,
+          opts.searchIndexes
+        );
+        const notOkStates = states.filter((s) => s.status !== IndexStatus.OK);
+        if (!notOkStates.length) {
+          this.logger.info(
+            `Collection ${collection.collectionName} is synced (${states.length} indexes)`
+          );
+          return;
+        }
+        this.logger.info(
+          `Collection ${collection.collectionName} is not synced (${notOkStates.length}/${states.length} indexes are not OK)`
+        );
+        const syncableStates = notOkStates.filter(
+          (s) => s.status === IndexStatus.NOT_DECLARED && dropIndexes || s.status === IndexStatus.MISSING && createIndexes || s.status === IndexStatus.OUTDATED && createIndexes
+        );
+        for (const state of syncableStates) {
+          try {
+            await this._createIndexFromState(collection, state);
+          } catch (err) {
+            this.logger.warn("Error while syncing indexes", { err, state });
+          }
+        }
+      },
+      async _createIndexFromState(col, state) {
+        if (state.status === IndexStatus.MISSING) {
+          this.logger.info(`Creating missing index`, { state });
+          if (state.type === "index") {
+            const [definition, options] = state.declaredIndex;
+            await col.createIndex(definition, options);
+          } else {
+            await col.createSearchIndex({
+              name: state.name,
+              definition: state.declaredSearchIndex
+            });
+          }
+        } else if (state.status === IndexStatus.NOT_DECLARED) {
+          this.logger.info(`Index is not declared, dropping it`, { state });
+          if (state.type === "index") {
+            if (!state.index.name || state.index.name === "_id_") {
+              throw new Error(
+                `Unable to delete index '${state.index.name}', invalid name`
+              );
+            }
+            await col.dropIndex(state.index.name);
+          } else {
+            await col.dropSearchIndex(state.name);
+          }
+        } else if (state.status === IndexStatus.OUTDATED) {
+          this.logger.info(`Index is outdated, updating it`, { state });
+          if (state.type === "index") {
+            this.logger.warn(
+              "Updating indexes is not supported, it should be done manually"
+            );
+          } else {
+            await col.updateSearchIndex(state.name, state.declaredSearchIndex);
+          }
+        } else {
+          this.logger.info(`Index is OK, doing nothing`, { state });
+        }
+      }
+    },
+    events: {
+      [DATABASE_INDEXES_MIXIN_SYNC_EVENT]: {
+        async handler(ctx) {
+          ctx.logger.info(
+            `Received sync indexes event for service ${this.name}`
+          );
+          await this._syncIndexes({ createIndexes: true, dropIndexes: false });
+        }
+      },
+      "$broker.started": {
+        async handler() {
+          await this._syncIndexes({
+            createIndexes: shouldAutoCreateIndexes(),
+            dropIndexes: shouldAutoDropIndexes()
+          });
+        }
+      }
+    }
+  });
+}
+
+function getFieldMode(fields) {
+  const refField = fields?.[0] === "-_id" ? fields?.[1] : fields?.[0];
+  if (refField && !refField.startsWith("-")) {
+    return "allow";
+  }
+  return "deny";
+}
+function filterFields(fields, secureFields) {
+  if (!secureFields?.length) {
+    return fields;
+  }
+  const mode = getFieldMode(fields);
+  switch (mode) {
+    case "deny": {
+      if (fields?.some((f) => !f.startsWith("-"))) {
+        throw new Error('All fields must have a "-" prefix in deny mode');
+      }
+      return [
+        .../* @__PURE__ */ new Set([...fields || [], ...secureFields.map((f) => `-${f}`)])
+      ];
+    }
+    case "allow": {
+      if (fields?.some((f) => f.startsWith("-") && f !== "-_id")) {
+        throw new Error('No fields must have a "-" prefix in allow mode');
+      }
+      const filteredFields = fields?.filter(
+        (f) => !secureFields.find((sF) => f === sF || f.startsWith(`${sF}.`))
+      );
+      if (filteredFields?.length === 0) {
+        return ["_id"];
+      }
+      return filteredFields;
+    }
+    default:
+      throw new Error("Should not happen");
+  }
+}
+function filterObjectFields(obj, fields) {
+  if (!fields?.length) {
+    return obj;
+  }
+  let res = obj;
+  const [fieldsRemove, fieldsAdd] = lodash.partition(
+    fields || [],
+    (f) => f.startsWith("-")
+  );
+  if (fieldsRemove.length) {
+    res = lodash.omit(
+      res,
+      fieldsRemove.map((f) => f.substring(1))
+    );
+  }
+  if (fieldsAdd.length) {
+    res = lodash.pick(res, fieldsAdd);
+  }
+  return res;
+}
+function getQueryFromList(type, list) {
+  if (!list?.length) {
+    return void 0;
+  }
+  const res = {};
+  list.forEach((el) => {
+    if (el.startsWith("-")) {
+      const p = el.slice(1);
+      res[p] = type === "sort" ? -1 : 0;
+    } else {
+      res[el] = 1;
+    }
+  });
+  return res;
+}
+
+function DatabaseMethodsMixin(opts) {
+  return index$1.wrapMixin({
+    methods: {
+      /**
+       * Helper function that clean an update aggregation pipeline from createdAt changes.
+       * Note: This method mutate the array.
+       */
+      _removeCreatedAtFromUpdateAggregationPipeline(changes) {
+        if (!Array.isArray(changes)) {
+          return;
+        }
+        for (const change of changes) {
+          if (change.$addFields?.createdAt !== void 0) {
+            delete change.$addFields.createdAt;
+          }
+          if (change.$set?.createdAt !== void 0) {
+            delete change.$set.createdAt;
+          }
+          if (typeof change.$unset === "string") {
+            change.$unset = [change.$unset];
+          }
+          if (Array.isArray(change.$unset) && change.$unset.includes("createdAt")) {
+            change.$unset.splice(change.$unset.indexOf("createdAt"), 1);
+            if (change.$unset.length === 0) {
+              changes.splice(changes.indexOf(change), 1);
+            }
+          }
+          if (change.$project) {
+            let isExcludeMode = false;
+            for (const [key, val] of Object.entries(change.$project)) {
+              if (key !== "_id" && (val === false || val === 0)) {
+                isExcludeMode = true;
+                break;
+              }
+            }
+            if (isExcludeMode) {
+              delete change.$project.createdAt;
+            } else {
+              change.$project.createdAt = true;
+            }
+            if (Object.keys(change.$project).length === 0) {
+              changes.splice(changes.indexOf(change), 1);
+            }
+          }
+        }
+      },
+      /**
+       * This method will automatically set the needed operators for our features (timestamps).
+       *
+       * Limitations of this method:
+       * - Dates are generated on the mongo server, except for `update` type with upsert.
+       * - It doesn't support $replaceWith/$replaceRoot in an aggregation pipeline except when using type `replace`.
+       * - Replaces (`replace` type) can only be done with an aggregation pipeline with a single $replaceWith stage.
+       * - Update aggregation pipelines will be modified to let the createdAt field stay the same.
+       */
+      _prepareUpdateFilter(changes, type) {
+        if (!opts.timestamps) {
+          return changes;
+        }
+        if (type === "replace") {
+          if (!Array.isArray(changes) || changes.length !== 1 || !changes[0].$replaceWith) {
+            throw new Error(
+              "Replace with timestamps can only go through an aggregation pipeline with a single $replaceWith stage"
+            );
+          }
+          return [
+            {
+              $replaceWith: {
+                $mergeObjects: [
+                  changes[0].$replaceWith,
+                  {
+                    createdAt: { $ifNull: ["$createdAt", "$$NOW"] },
+                    updatedAt: "$$NOW"
+                  }
+                ]
+              }
+            }
+          ];
+        }
+        if (Array.isArray(changes)) {
+          if (changes.some((change) => change.$replaceWith || change.$replaceRoot)) {
+            throw new Error(
+              "$replaceWith/$replaceRoot can't be used in an update aggregation pipeline."
+            );
+          }
+          this._removeCreatedAtFromUpdateAggregationPipeline(changes);
+          return [
+            ...changes,
+            {
+              $set: {
+                createdAt: { $ifNull: ["$createdAt", "$$NOW"] },
+                updatedAt: "$$NOW"
+              }
+            }
+          ];
+        }
+        for (const operator of Object.values(changes)) {
+          for (const key of Object.keys(operator)) {
+            if (key === "createdAt" || key === "updatedAt") {
+              delete operator[key];
+            }
+          }
+        }
+        const $currentDate = changes.$currentDate || {};
+        const $setOnInsert = changes.$setOnInsert || {};
+        $currentDate.updatedAt = true;
+        if (type === "create") {
+          $currentDate.createdAt = true;
+        } else {
+          $setOnInsert.createdAt = /* @__PURE__ */ new Date();
+        }
+        return {
+          ...changes,
+          // @ts-expect-error $currentDate is not always here for TS
+          $currentDate,
+          // @ts-expect-error $setOnInsert is not always here for TS
+          $setOnInsert
+        };
+      },
+      /**
+       * Will get the tenant filter from params.
+       * This filter should be used in all read queries to ensure that the user
+       * can only access documents that belong to the same tenant.
+       */
+      _getTenantFilter(params, strict = true) {
+        const { tenantField } = opts;
+        if (!tenantField) {
+          return {};
+        }
+        if (!params?.[tenantField]) {
+          if (!strict) {
+            return {};
+          }
+          throw new Error(`Missing tenant field "${tenantField}" in params`);
+        }
+        return { [tenantField]: params[tenantField] };
+      },
+      /**
+       * Will get the soft delete filter from params.
+       * This filter should be used in all read queries.
+       *
+       * Indexes should also index the deleted field to ensure optimal performance.
+       * Note that in order to support partial indexes, a non deleted field is checked
+       * for `false` and `null` values.
+       */
+      _getSoftDeleteFilter(scope) {
+        if (!opts.softDelete) {
+          return {};
+        }
+        switch (scope) {
+          case "only-deleted":
+            return { deletedAt: { $gte: 0 } };
+          case "no-deleted":
+          case void 0:
+            return { deletedAt: null };
+          case "include-deleted":
+            return {};
+          default:
+            throw new Error(`Unknown soft delete scope ${scope}`);
+        }
+      },
+      /**
+       * Get a query filter optimized ($or problem) with additional filters applied:
+       * - Tenant filter
+       * - Soft delete filter
+       */
+      _getQueryFilter(query, params, scope, strictTenantFilter = true) {
+        return optimizeQuery({
+          ...query,
+          ...this._getTenantFilter(params, strictTenantFilter),
+          ...this._getSoftDeleteFilter(scope)
+        });
+      },
+      /**
+       * INTERNAL, DO NOT USE.
+       * Simple wrapper around the DatabaseConnectionMixin.getCollection method to have typed collection.
+       */
+      _getDatabaseMixinCollection(options) {
+        return this.getCollection(options);
+      },
+      /**
+       * Create a find cursor with database mixin options applied.
+       */
+      _createFindCursor(query, params, options = {}) {
+        const {
+          sort,
+          fields,
+          scope,
+          strictTenantFilter = true,
+          ...driverOptions
+        } = options;
+        return this._getDatabaseMixinCollection().find(
+          this._getQueryFilter(query, params, scope, strictTenantFilter),
+          {
+            ...driverOptions,
+            sort: getQueryFromList("sort", sort),
+            projection: getQueryFromList("projection", fields)
+          }
+        );
+      },
+      async _findOne(query, params, options) {
+        const cursor = this._createFindCursor(query, params, {
+          ...options,
+          limit: -1,
+          batchSize: 1
+        });
+        const res = await cursor.next();
+        await cursor.close();
+        return res;
+      },
+      _find(query, params, options) {
+        return this._createFindCursor(query, params, options).toArray();
+      },
+      _findStream(query, params, options) {
+        return this._createFindCursor(query, params, options).stream();
+      },
+      _countDocuments(query, params, options = {}) {
+        const { scope, strictTenantFilter = true, ...driverOptions } = options;
+        return this._getDatabaseMixinCollection().countDocuments(
+          this._getQueryFilter(query, params, scope, strictTenantFilter),
+          driverOptions
+        );
+      },
+      /**
+       * Insert one document and return it.
+       *
+       * It differs from the driver's insertOne as it returns the inserted document and
+       * send an event with the new document.
+       */
+      async _insertOne(ctx, doc, options = {}) {
+        const { fields, skipCreateEvent, ...driverOptions } = options;
+        if (opts.idGenerator && !doc._id) {
+          doc._id = opts.idGenerator(doc);
+        }
+        const res = await this._getDatabaseMixinCollection().findOneAndUpdate(
+          { _id: { $exists: false } },
+          this._prepareUpdateFilter(
+            { $setOnInsert: doc },
+            "create"
+          ),
+          {
+            ...driverOptions,
+            includeResultMetadata: false,
+            // Document says it's true by default and will be false in a next major
+            upsert: true,
+            returnDocument: "after",
+            projection: getQueryFromList("projection", fields)
+          }
+        );
+        if (!res) {
+          throw new Error("Insert one didn't upsert any document");
+        }
+        if (opts.eventPrefix && !skipCreateEvent) {
+          ctx.emit(
+            `${opts.eventPrefix}.created`,
+            { type: "insert", document: res }
+          );
+        }
+        return res;
+      },
+      /**
+       * Insert many documents and return the list of inserted ids in the same order.
+       */
+      async _insertMany(ctx, docs, options = {}) {
+        const { skipCreateEvent, ...driverOptions } = options;
+        const res = await this._getDatabaseMixinCollection().bulkWrite(
+          docs.map((doc) => {
+            if (opts.idGenerator && !doc._id) {
+              doc._id = opts.idGenerator(doc);
+            }
+            return {
+              updateOne: {
+                upsert: true,
+                filter: { _id: { $exists: false } },
+                update: this._prepareUpdateFilter(
+                  { $setOnInsert: doc },
+                  "create"
+                )
+              }
+            };
+          }),
+          driverOptions
+        );
+        if (opts.eventPrefix && !skipCreateEvent) {
+          docs.forEach(
+            (doc, i) => ctx.emit(
+              `${opts.eventPrefix}.created`,
+              {
+                type: "insert",
+                document: {
+                  _id: doc._id || res.upsertedIds[i],
+                  ...doc
+                }
+              }
+            )
+          );
+        }
+        return docs.map((doc, i) => res.upsertedIds[i]);
+      },
+      /**
+       * Update one document and return the after version by default.
+       * To have the before version, use the `returnDocument` option.
+       *
+       * WARNING: Only send an event if returnDocument is 'after'.If returnDocument is 'before',
+       * you MUST pass skipUpdateEvent: true and optionally send the event yourself.
+       */
+      async _updateOne(ctx, query, params, changes, options = {}) {
+        const {
+          fields,
+          sort,
+          strictTenantFilter = true,
+          returnDocument = "after",
+          skipUpdateEvent,
+          ...driverOptions
+        } = options;
+        if (returnDocument === "before" && opts.eventPrefix && !skipUpdateEvent) {
+          throw new Error(
+            "Cannot send update event with returnDocument: before option"
+          );
+        }
+        const res = await this._getDatabaseMixinCollection().findOneAndUpdate(
+          this._getQueryFilter(query, params, "no-deleted", strictTenantFilter),
+          this._prepareUpdateFilter(changes, "update"),
+          {
+            ...driverOptions,
+            returnDocument,
+            includeResultMetadata: false,
+            // Document says it's true by default and will be false in a next major
+            sort: getQueryFromList("sort", sort),
+            projection: getQueryFromList("projection", fields)
+          }
+        );
+        if (res && opts.eventPrefix && !skipUpdateEvent) {
+          ctx.emit(
+            `${opts.eventPrefix}.updated`,
+            { type: "update", document: res }
+          );
+        }
+        return res;
+      },
+      /**
+       * Update many documents and return the number of updated documents.
+       *
+       * WARNING: Do not send any events. You'll have to send an event yourself.
+       */
+      async _updateMany(query, params, changes, options = {}) {
+        const { strictTenantFilter = true, ...driverOptions } = options;
+        return this._getDatabaseMixinCollection().updateMany(
+          this._getQueryFilter(query, params, "no-deleted", strictTenantFilter),
+          this._prepareUpdateFilter(changes, "update"),
+          driverOptions
+        );
+      },
+      /**
+       * Replace one document and return the after version by default.
+       * To have the before version, use the `returnDocument` option.
+       *
+       * WARNING: Only send an event if returnDocument is 'after'.If returnDocument is 'before',
+       * you MUST pass skipUpdateEvent: true and optionally send the event yourself.
+       */
+      async _replaceOne(ctx, query, params, doc, options = {}) {
+        const {
+          fields,
+          sort,
+          strictTenantFilter = true,
+          returnDocument = "after",
+          skipUpdateEvent,
+          ...driverOptions
+        } = options;
+        if (returnDocument === "before" && opts.eventPrefix && !skipUpdateEvent) {
+          throw new Error(
+            "Cannot send update event with returnDocument: before option"
+          );
+        }
+        const res = await this._getDatabaseMixinCollection().findOneAndUpdate(
+          this._getQueryFilter(query, params, "no-deleted", strictTenantFilter),
+          this._prepareUpdateFilter(
+            [{ $replaceWith: { $literal: doc } }],
+            "replace"
+          ),
+          {
+            ...driverOptions,
+            returnDocument,
+            includeResultMetadata: false,
+            // Document says it's true by default and will be false in a next major
+            sort: getQueryFromList("sort", sort),
+            projection: getQueryFromList("projection", fields)
+          }
+        );
+        if (res && opts.eventPrefix && !skipUpdateEvent) {
+          ctx.emit(
+            `${opts.eventPrefix}.updated`,
+            { type: "replace", document: res }
+          );
+        }
+        return res;
+      },
+      /**
+       * Delete one document and return it.
+       * If soft delete is enabled, it will only set the deleted field to true (hiding it from future requests).
+       */
+      async _deleteOne(ctx, query, params, options) {
+        const {
+          sort,
+          fields,
+          strictTenantFilter = true,
+          skipDeleteEvent,
+          ...driverOptions
+        } = options || {};
+        let res;
+        if (opts.softDelete) {
+          res = await this._getDatabaseMixinCollection().findOneAndUpdate(
+            this._getQueryFilter(
+              query,
+              params,
+              "no-deleted",
+              strictTenantFilter
+            ),
+            this._prepareUpdateFilter(
+              // @ts-expect-error deletedAt is not always here for TS
+              { $currentDate: { deletedAt: true } },
+              "update"
+            ),
+            {
+              ...driverOptions,
+              includeResultMetadata: false,
+              // Document says it's true by default and will be false in a next major
+              sort: getQueryFromList("sort", sort),
+              projection: getQueryFromList("projection", fields),
+              returnDocument: "before"
+            }
+          );
+        } else {
+          res = await this._getDatabaseMixinCollection().findOneAndDelete(
+            this._getQueryFilter(
+              query,
+              params,
+              "no-deleted",
+              strictTenantFilter
+            ),
+            {
+              ...driverOptions,
+              sort: getQueryFromList("sort", sort),
+              projection: getQueryFromList("projection", fields)
+            }
+          );
+        }
+        if (res && opts.eventPrefix && !skipDeleteEvent) {
+          ctx.emit(
+            `${opts.eventPrefix}.deleted`,
+            { type: "delete", document: res }
+          );
+        }
+        return res;
+      },
+      /**
+       * Delete many documents and return the number of deleted documents.
+       * If soft delete is enabled, it will only set the deleted field to true (hiding it from future requests).
+       *
+       * WARNING: Do not send any events. You'll have to send an event yourself.
+       */
+      async _deleteMany(query, params, options) {
+        const { strictTenantFilter = true, ...driverOptions } = options || {};
+        if (opts.softDelete) {
+          const res2 = await this._getDatabaseMixinCollection().updateMany(
+            this._getQueryFilter(
+              query,
+              params,
+              "no-deleted",
+              strictTenantFilter
+            ),
+            this._prepareUpdateFilter(
+              // @ts-expect-error deletedAt is not always here for TS
+              { $currentDate: { deletedAt: true } },
+              "update"
+            ),
+            driverOptions
+          );
+          return res2.modifiedCount;
+        }
+        const res = await this._getDatabaseMixinCollection().deleteMany(
+          this._getQueryFilter(query, params, "no-deleted", strictTenantFilter),
+          driverOptions
+        );
+        return res.deletedCount;
+      }
+    },
+    actions: createActions(opts),
+    created() {
+      if (!("getMongoClient" in this)) {
+        throw new Error(
+          "DatabaseConnectionMixin is required to use DatabaseMethodsMixin"
+        );
+      }
+    }
+  });
+}
+
+exports.AjvActionSchemaFactory = AjvActionSchemaFactory;
+exports.DATABASE_INDEXES_MIXIN_SYNC_EVENT = DATABASE_INDEXES_MIXIN_SYNC_EVENT;
+exports.DatabaseConnectionMixin = DatabaseConnectionMixin;
+exports.DatabaseIndexesMixin = DatabaseIndexesMixin;
+exports.DatabaseMethodsMixin = DatabaseMethodsMixin;
+exports.EntityNotFoundError = EntityNotFoundError;
+exports.IndexStatus = IndexStatus;
+exports.QueryOp = QueryOp;
+exports.ZodActionSchemaFactory = ZodActionSchemaFactory;
+exports.addQueryOps = addQueryOps;
+exports.addZodQueryOps = addZodQueryOps;
+exports.createActions = createActions;
+exports.filterFields = filterFields;
+exports.filterObjectFields = filterObjectFields;
+exports.getDefaultIndexName = getDefaultIndexName;
+exports.getIndexesDifference = getIndexesDifference$1;
+exports.getQueryFromList = getQueryFromList;
+exports.isIndexEqual = isIndexEqual;
+exports.isIndexNameEqual = isIndexNameEqual;
+exports.isOnAtlas = isOnAtlas;
+exports.optimizeQuery = optimizeQuery;
+exports.optionalMongoId = optionalMongoId;
+exports.parseAndValidateQuery = parseAndValidateQuery;
+exports.parseStringifiedQuery = parseStringifiedQuery;
+exports.removeMongoId = removeMongoId;
+exports.shouldAutoCreateIndexes = shouldAutoCreateIndexes;
+exports.shouldAutoDropIndexes = shouldAutoDropIndexes;