@orion-js/mongodb 4.3.1 → 4.5.0

package/dist/index.d.ts

@@ -1,391 +1,6 @@
-import * as MongoDB from 'mongodb';
-import { MongoClient, Db, MongoClientOptions, EnhancedOmit, KMSProviders, AWSEncryptionKeyOptions, UUID } from 'mongodb';
-export { MongoDB };
-import { Schema, SchemaInAnyOrionForm, StrictInferSchemaType, TypedSchemaOnSchema, InferSchemaType, FieldType } from '@orion-js/schema';
-
-interface OrionMongoClient {
-    client: MongoClient;
-    db: Db;
-    uri: string;
-    dbName: string;
-    /**
-     * @deprecated Use startConnection() instead. This property is not guaranteed to be resolved if the connection is not started.
-     * When using async calls startConnection or connectionPromise is no longer needed. Orion will automatically start the connection if it is not already started.
-     * Kept for backwards compatibility. startConnection does not re-start the connection if it is already started, so it is safe to use.
-     */
-    connectionPromise: Promise<MongoClient>;
-    connectionName: string;
-    encrypted: {
-        client: MongoClient;
-        db: Db;
-    };
-    /**
-     * Starts the connection if it is not already started.
-     * If the connection is already started, it resolves immediately.
-     */
-    startConnection: () => Promise<MongoClient>;
-    closeConnection: () => Promise<void>;
-}
-declare class OrionMongoDatabaseWrapper implements OrionMongoClient {
-    uri: string;
-    dbName: string;
-    connectionName: string;
-    connectionPromise: Promise<MongoClient>;
-    private mongoOptions;
-    private connectionEvent;
-    private state;
-    client: MongoClient;
-    db: Db;
-    configured: boolean;
-    readonly encrypted: {
-        client: MongoClient;
-        db: Db;
-    };
-    readonly configTimeout: NodeJS.Timeout;
-    constructor(connectionName: string);
-    config(mongoURL: string, mongoOptions: MongoClientOptions): void;
-    awaitConnection(): Promise<this>;
-    connectWithRetry(client: MongoClient): Promise<MongoClient>;
-    startConnection(): Promise<MongoClient>;
-    closeConnection(): Promise<void>;
-}
-declare function configureConnection(connectionName: string, mongoOptions: MongoClientOptions): Promise<OrionMongoDatabaseWrapper>;
-declare const connections: {
-    [key: string]: OrionMongoDatabaseWrapper;
-};
-
-declare const allConnectionPromises: any[];
-interface MongoConnectOptions {
-    name: string;
-    uri?: string;
-}
-declare const getMongoConnection: ({ name, uri }: MongoConnectOptions) => OrionMongoClient;
-
-declare function getDBName(url: string): string;
-
-type OptionalId<T> = MongoDB.OptionalId<T>;
-declare type InferIdType<TSchema> = TSchema extends {
-    _id: infer IdType;
-} ? Record<any, never> extends IdType ? never : IdType : TSchema extends {
-    _id?: infer IdType;
-} ? unknown extends IdType ? string : IdType : string;
-type DocumentWithId<TSchema> = EnhancedOmit<TSchema, '_id'> & {
-    _id: InferIdType<TSchema>;
-};
-type ModelClassBase = DocumentWithId<MongoDB.Document>;
-/**
- * Index definition for a MongoDB collection.
- * Supports flat options (recommended) or nested options object (deprecated).
- *
- * @example New format (recommended):
- * ```ts
- * { keys: { email: 1 }, unique: true, sparse: true }
- * ```
- *
- * @example Old format (deprecated):
- * ```ts
- * { keys: { email: 1 }, options: { unique: true, sparse: true } }
- * ```
- */
-interface CollectionIndex extends Partial<MongoDB.CreateIndexesOptions> {
-    keys: MongoDB.IndexSpecification;
-    /**
-     * @deprecated Use flat options instead. Example: `{ keys: { email: 1 }, unique: true }`
-     * instead of `{ keys: { email: 1 }, options: { unique: true } }`
-     */
-    options?: MongoDB.CreateIndexesOptions;
-}
-declare namespace DataLoader {
-    interface LoadDataOptionsBase<ModelClass extends ModelClassBase> {
-        key: keyof ModelClass;
-        match?: MongoFilter<ModelClass>;
-        sort?: MongoDB.Sort;
-        project?: MongoDB.Document;
-        timeout?: number;
-        debug?: boolean;
-    }
-    export interface LoadDataOptions<ModelClass extends ModelClassBase> extends LoadDataOptionsBase<ModelClass> {
-        value?: any;
-        values?: Array<any>;
-    }
-    export interface LoadOneOptions<ModelClass extends ModelClassBase> extends LoadDataOptionsBase<ModelClass> {
-        value: any;
-    }
-    export type LoadData<ModelClass extends ModelClassBase> = (options: LoadDataOptions<ModelClass>) => Promise<Array<ModelClass>>;
-    export type LoadOne<ModelClass extends ModelClassBase> = (options: LoadOneOptions<ModelClass>) => Promise<ModelClass>;
-    export type LoadMany<ModelClass extends ModelClassBase> = (options: LoadDataOptions<ModelClass>) => Promise<Array<ModelClass>>;
-    export type LoadById<ModelClass extends ModelClassBase> = (id: ModelClass['_id']) => Promise<ModelClass>;
-    export {  };
-}
-type MongoFilter<ModelClass extends ModelClassBase = ModelClassBase> = MongoDB.Filter<ModelClass>;
-type MongoSelector<ModelClass extends ModelClassBase = ModelClassBase> = ModelClass['_id'] | MongoFilter<ModelClass>;
-interface FindCursor<ModelClass> extends MongoDB.FindCursor {
-    toArray: () => Promise<Array<ModelClass>>;
-}
-interface UpdateOptions {
-    clean?: boolean;
-    validate?: boolean;
-    mongoOptions?: MongoDB.UpdateOptions;
-}
-interface FindOneAndUpdateUpdateOptions {
-    clean?: boolean;
-    validate?: boolean;
-    mongoOptions?: MongoDB.FindOneAndUpdateOptions;
-}
-interface InsertOptions {
-    clean?: boolean;
-    validate?: boolean;
-    mongoOptions?: MongoDB.InsertOneOptions;
-}
-interface InsertManyOptions {
-    clean?: boolean;
-    validate?: boolean;
-    mongoOptions?: MongoDB.BulkWriteOptions;
-}
-type InitItem<ModelClass extends ModelClassBase> = (doc: any) => ModelClass;
-type ModelToMongoSelector<ModelClass extends ModelClassBase> = MongoDB.Filter<ModelClass> | DocumentWithId<ModelClass>['_id'];
-type FindOne<ModelClass extends ModelClassBase> = (selector?: ModelToMongoSelector<ModelClass>, options?: MongoDB.FindOptions<ModelClass>) => Promise<ModelClass>;
-type Find<ModelClass extends ModelClassBase> = (selector?: ModelToMongoSelector<ModelClass>, options?: MongoDB.FindOptions<ModelClass>) => FindCursor<ModelClass>;
-type FindOneAndUpdate<ModelClass extends ModelClassBase> = <TSelector extends ModelToMongoSelector<ModelClass>, TFilter extends MongoDB.UpdateFilter<ModelClass>, TOptions extends FindOneAndUpdateUpdateOptions>(selector: TSelector, modifier: TFilter, options?: TOptions) => ReturnType<MongoDB.Collection<ModelClass>['findOneAndUpdate']>;
-type UpdateAndFind<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: MongoDB.UpdateFilter<ModelClass>, options?: FindOneAndUpdateUpdateOptions) => Promise<ModelClass>;
-type UpdateItem<ModelClass extends ModelClassBase> = (item: ModelClass, modifier: MongoDB.UpdateFilter<ModelClass>, options?: FindOneAndUpdateUpdateOptions) => Promise<void>;
-type InsertOne<ModelClass extends ModelClassBase> = (doc: MongoDB.OptionalId<ModelClass>, options?: InsertOptions) => Promise<ModelClass['_id']>;
-type InsertMany<ModelClass extends ModelClassBase> = (doc: Array<MongoDB.OptionalId<ModelClass>>, options?: InsertManyOptions) => Promise<Array<ModelClass['_id']>>;
-type InsertAndFind<ModelClass extends ModelClassBase> = (doc: MongoDB.OptionalId<ModelClass>, options?: InsertOptions) => Promise<ModelClass>;
-type DeleteMany<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, options?: MongoDB.DeleteOptions) => Promise<MongoDB.DeleteResult>;
-type DeleteOne<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, options?: MongoDB.DeleteOptions) => Promise<MongoDB.DeleteResult>;
-type UpdateOne<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: MongoDB.UpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult>;
-type UpdateMany<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: MongoDB.UpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult | MongoDB.Document>;
-type Upsert<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, modifier: MongoDB.UpdateFilter<ModelClass>, options?: UpdateOptions) => Promise<MongoDB.UpdateResult>;
-interface CreateCollectionOptions<ModelClass extends ModelClassBase = ModelClassBase> {
-    /**
-     * The name of the collection on the Mongo Database
-     */
-    name: string;
-    /**
-     * The name of the connection to use. The Mongo URL of this connection will be search on env variables.
-     * If not found, the connection url will be `env.mongo_url`
-     * If defined, the connection url will be `env.mongo_url_${name}`
-     */
-    connectionName?: string;
-    /**
-     * The schema used for cleaning and validation of the documents
-     */
-    schema?: SchemaInAnyOrionForm;
-    /**
-     * The indexes to use
-     */
-    indexes?: Array<CollectionIndex>;
-    /**
-     * Select between random id generation o mongo (time based) id generation
-     */
-    idGeneration?: 'mongo' | 'random' | 'uuid';
-    /**
-     * ID prefix. idGeneration will be forced to random. Recommended for type checking
-     */
-    idPrefix?: ModelClass['_id'];
-}
-type EstimatedDocumentCount<_ModelClass extends ModelClassBase> = (options?: MongoDB.EstimatedDocumentCountOptions) => Promise<number>;
-type CountDocuments<ModelClass extends ModelClassBase> = (selector: ModelToMongoSelector<ModelClass>, options?: MongoDB.CountDocumentsOptions) => Promise<number>;
-type SchemaWithRequiredId = Schema & {
-    _id: {
-        type: any;
-    };
-};
-type InferSchemaTypeWithId<TSchema extends SchemaWithRequiredId> = DocumentWithId<StrictInferSchemaType<TSchema>>;
-type CreateCollectionOptionsWithSchemaType<T extends SchemaWithRequiredId> = {
-    schema: T;
-} & Omit<CreateCollectionOptions<InferSchemaTypeWithId<T>>, 'schema'>;
-type CreateCollectionOptionsWithTypedSchema<T extends TypedSchemaOnSchema & {
-    prototype: {
-        _id: string;
-    };
-}> = {
-    schema: T;
-} & Omit<CreateCollectionOptions<InferSchemaType<T>>, 'schema'>;
-declare class BaseCollection<ModelClass extends ModelClassBase = ModelClassBase> {
-    name: string;
-    connectionName?: string;
-    schema?: Schema;
-    generateId: () => ModelClass['_id'];
-    getSchema: () => Schema;
-    db: MongoDB.Db;
-    client: OrionMongoClient;
-    /**
-     * @deprecated Use getRawCollection() instead. This property is not guaranteed to be defined if the connection has not been started.
-     */
-    rawCollection: MongoDB.Collection<ModelClass>;
-    getRawCollection: () => Promise<MongoDB.Collection<ModelClass>>;
-    findOne: FindOne<ModelClass>;
-    find: Find<ModelClass>;
-    insertOne: InsertOne<ModelClass>;
-    insertMany: InsertMany<ModelClass>;
-    insertAndFind: InsertAndFind<ModelClass>;
-    deleteMany: DeleteMany<ModelClass>;
-    deleteOne: DeleteOne<ModelClass>;
-    updateOne: UpdateOne<ModelClass>;
-    updateMany: UpdateMany<ModelClass>;
-    upsert: Upsert<ModelClass>;
-    findOneAndUpdate: FindOneAndUpdate<ModelClass>;
-    /**
-     * Updates a document and returns the updated document with the changes
-     */
-    updateAndFind: UpdateAndFind<ModelClass>;
-    updateItem: UpdateItem<ModelClass>;
-    estimatedDocumentCount: EstimatedDocumentCount<ModelClass>;
-    countDocuments: CountDocuments<ModelClass>;
-    aggregate: <T = MongoDB.Document>(pipeline?: MongoDB.Document[], options?: MongoDB.AggregateOptions) => MongoDB.AggregationCursor<T>;
-    watch: <T = MongoDB.Document>(pipeline?: MongoDB.Document[], options?: MongoDB.ChangeStreamOptions) => MongoDB.ChangeStream<T>;
-    loadData: DataLoader.LoadData<ModelClass>;
-    loadOne: DataLoader.LoadOne<ModelClass>;
-    loadMany: DataLoader.LoadMany<ModelClass>;
-    loadById: DataLoader.LoadById<ModelClass>;
-    /**
-     * Use this function if you are using tests and you pass the
-     * env var DONT_CREATE_INDEXES_AUTOMATICALLY and you need to
-     * create the indexes for this collection
-     */
-    createIndexes: () => Promise<string[]>;
-    createIndexesPromise: Promise<string[]>;
-    /**
-     * Deletes indexes that exist in MongoDB but are not defined in the collection configuration.
-     * This helps clean up stale indexes that are no longer needed.
-     * Always preserves the _id_ index.
-     */
-    deleteUnusedIndexes: () => Promise<{
-        deletedIndexes: string[];
-        collectionName: string;
-    }>;
-    /**
-     * @deprecated Use startConnection() instead. This property is not guaranteed to be resolved if the connection is not started.
-     * When using async calls startConnection or connectionPromise is no longer needed. Orion will automatically start the connection if it is not already started.
-     * Kept for backwards compatibility. startConnection does not re-start the connection if it is already started, so it is safe to use.
-     */
-    connectionPromise: Promise<MongoDB.MongoClient>;
-    startConnection: () => Promise<MongoDB.MongoClient>;
-}
-declare class Collection<ModelClass extends ModelClassBase = ModelClassBase> extends BaseCollection<ModelClass> {
-    indexes: Array<CollectionIndex>;
-    encrypted?: BaseCollection<ModelClass>;
-}
-type DistinctDocumentId<DistinctId extends string> = string & {
-    __TYPE__: `DistinctDocumentId<${DistinctId}>`;
-};
-type TypedId<TPrefix extends string> = `${TPrefix}-${string}`;
-/**
- * Use this function to create unique types for the ids of mongodb documents.
- * You should set it as the type of the _id field in your schema.
- *
- * @example
- * ```ts
- * type UserId = TypedId<'user'>
- *
- * const userSchema = {
- *   _id: {
- *     type: TypedId('user'),
- *   },
- * }
- *
- * ```
- */
-declare function typedId<const TPrefix extends string>(prefix: TPrefix): FieldType<TypedId<TPrefix>> & {
-    generateId: () => TypedId<TPrefix>;
-};
-
-declare function Repository(): (target: any, context: ClassDecoratorContext<any>) => void;
-declare function MongoCollection<ModelClass extends ModelClassBase = ModelClassBase>(options: CreateCollectionOptions<ModelClass>): (_target: any, context: ClassFieldDecoratorContext) => void;
-
-declare const createIndexesPromises: any[];
-declare function createCollection<T extends SchemaWithRequiredId>(options: CreateCollectionOptionsWithSchemaType<T>): Collection<InferSchemaTypeWithId<T>>;
-declare function createCollection<T extends TypedSchemaOnSchema & {
-    prototype: {
-        _id: string;
-    };
-}>(options: CreateCollectionOptionsWithTypedSchema<T>): Collection<InferSchemaType<T>>;
-declare function createCollection<T extends ModelClassBase>(options: CreateCollectionOptions<T>): Collection<T>;
-
-/**
- * Result of the deleteUnusedIndexes operation
- */
-interface DeleteUnusedIndexesResult {
-    /** Names of the indexes that were deleted */
-    deletedIndexes: string[];
-    /** Name of the collection that was cleaned */
-    collectionName: string;
-}
-
-/**
- * Registry that tracks all collections created via createCollection().
- * Maps connection name to a map of collection name to collection instance.
- * When the same collection is registered multiple times, indexes are merged.
- */
-declare const collectionsRegistry: Map<string, Map<string, Collection<ModelClassBase>>>;
-/**
- * Registers a collection in the registry.
- * Called automatically when a collection is created via createCollection().
- * If the same collection name is registered multiple times, indexes are merged
- * to support multiple createCollection() calls for the same collection.
- * @param connectionName - The name of the MongoDB connection
- * @param collection - The collection instance to register
- */
-declare function registerCollection(connectionName: string, collection: Collection<ModelClassBase>): void;
-/**
- * Gets all registered collections for a specific connection.
- * @param connectionName - The name of the MongoDB connection (defaults to 'main')
- * @returns Array of registered collections for the connection
- */
-declare function getRegisteredCollections(connectionName?: string): Array<Collection<ModelClassBase>>;
-/**
- * Gets the merged indexes for a specific collection from the registry.
- * This includes all indexes from all createCollection() calls for the same collection name.
- * @param connectionName - The name of the MongoDB connection
- * @param collectionName - The name of the collection
- * @returns Array of merged index definitions, or empty array if collection not registered
- */
-declare function getMergedIndexes(connectionName: string, collectionName: string): CollectionIndex[];
-/**
- * Deletes unused indexes from all registered collections for a connection.
- * Iterates over all collections registered via createCollection() and
- * removes indexes that exist in MongoDB but are not defined in the collection configuration.
- *
- * **Important**: This function waits for all pending index creation to complete before
- * deleting any indexes, to avoid race conditions where an index being created might
- * be incorrectly identified as unused.
- *
- * @param connectionName - The name of the MongoDB connection (defaults to 'main')
- * @returns Array of results for each collection that had indexes deleted
- *
- * @example
- * ```ts
- * // Delete unused indexes from all collections on the main connection
- * const results = await deleteAllUnusedIndexes()
- *
- * // Delete unused indexes from all collections on a specific connection
- * const results = await deleteAllUnusedIndexes('secondary')
- *
- * // Log results
- * for (const result of results) {
- *   console.log(`${result.collectionName}: deleted ${result.deletedIndexes.length} indexes`)
- * }
- * ```
- */
-declare function deleteAllUnusedIndexes(connectionName?: string): Promise<DeleteUnusedIndexesResult[]>;
-
-declare function getOrCreateEncryptionKey({ keyAltName, kmsProvider, masterKey, connectionName, keyVaultDatabase, keyVaultCollection, kmsProviders, }: {
-    keyAltName: string;
-    kmsProvider: keyof KMSProviders;
-    masterKey?: AWSEncryptionKeyOptions;
-    connectionName?: string;
-    keyVaultDatabase?: string;
-    keyVaultCollection?: string;
-    kmsProviders: KMSProviders;
-}): Promise<{
-    key: UUID;
-    keyVaultNamespace: string;
-}>;
-declare const ENCRYPTION_ALGORITHMS: {
-    DETERMINISTIC: string;
-    RANDOM: string;
-};
-
-export { BaseCollection, Collection, type CollectionIndex, type CountDocuments, type CreateCollectionOptions, type CreateCollectionOptionsWithSchemaType, type CreateCollectionOptionsWithTypedSchema, DataLoader, type DeleteMany, type DeleteOne, type DistinctDocumentId, type DocumentWithId, ENCRYPTION_ALGORITHMS, type EstimatedDocumentCount, type Find, type FindCursor, type FindOne, type FindOneAndUpdate, type FindOneAndUpdateUpdateOptions, type InferIdType, type InferSchemaTypeWithId, type InitItem, type InsertAndFind, type InsertMany, type InsertManyOptions, type InsertOne, type InsertOptions, type ModelClassBase, type ModelToMongoSelector, MongoCollection, type MongoFilter, type MongoSelector, type OptionalId, Repository, type SchemaWithRequiredId, type TypedId, type UpdateAndFind, type UpdateItem, type UpdateMany, type UpdateOne, type UpdateOptions, type Upsert, allConnectionPromises, collectionsRegistry, configureConnection, connections, createCollection, createIndexesPromises, deleteAllUnusedIndexes, getDBName, getMergedIndexes, getMongoConnection, getOrCreateEncryptionKey, getRegisteredCollections, registerCollection, typedId };
+export * from './connect';
+export * from './types';
+export * from './service';
+export * from './createCollection';
+export * from './createCollection/collectionsRegistry';
+export * from './encrypted/getOrCreateEncryptionKey';

package/dist/index.js

@@ -489,8 +489,8 @@ function findOne_default(collection) {
   return findOne;
 }
 
-// src/createCollection/getMethods/validateModifier/validatePush.ts
-import { validate } from "@orion-js/schema";
+// src/createCollection/getMethods/cleanModifier.ts
+import { cleanKey, clean } from "@orion-js/schema";
 
 // src/helpers/fromDot.ts
 import dot2 from "dot-object";
@@ -508,7 +508,70 @@ function fromDot(doc) {
   return dot2.object(doc);
 }
 
+// src/createCollection/getMethods/cleanModifier.ts
+var shouldCheck = (key) => {
+  if (key === "$pushAll") throw new Error("$pushAll is not supported; use $push + $each");
+  return ["$pull", "$pullAll", "$pop", "$slice"].indexOf(key) === -1;
+};
+async function cleanModifier(schema, modifier, { isUpsert } = { isUpsert: false }) {
+  const cleanedModifier = {};
+  for (const operation of Object.keys(modifier)) {
+    const operationDoc = modifier[operation];
+    cleanedModifier[operation] = {};
+    if (operation.slice(0, 1) !== "$") {
+      throw new Error(`Expected '${operation}' to be a modifier operator like '$set'`);
+    }
+    if (!shouldCheck(operation)) {
+      cleanedModifier[operation] = operationDoc;
+      continue;
+    }
+    for (const key of Object.keys(operationDoc)) {
+      const value = operationDoc[key];
+      const cleanOptions = { forceDoc: operationDoc };
+      let cleaned = null;
+      if (operation === "$push" || operation === "$addToSet") {
+        if (typeof value === "object" && "$each" in value) {
+          const $each = await cleanKey(schema, key, value.$each, cleanOptions);
+          cleaned = { ...value, $each };
+        } else {
+          cleaned = await cleanKey(schema, `${key}.0`, value, cleanOptions);
+        }
+      }
+      if (operation === "$set") {
+        cleaned = await cleanKey(schema, key, value, cleanOptions);
+      }
+      if (operation === "$setOnInsert") {
+        cleaned = await cleanKey(schema, key, value, cleanOptions);
+      }
+      if (operation === "$inc") {
+        cleaned = await cleanKey(schema, key, value, cleanOptions);
+      }
+      if (operation === "$unset") {
+        const isPresent = await cleanKey(schema, key, "anyvalue", cleanOptions);
+        cleaned = !isNil(isPresent) ? "" : null;
+      }
+      if (cleaned !== void 0) {
+        cleanedModifier[operation][key] = cleaned;
+      }
+    }
+    if (isEmpty(cleanedModifier[operation])) {
+      delete cleanedModifier[operation];
+    }
+  }
+  if (isUpsert) {
+    const cleanedSetOnInsert = await clean(schema, fromDot(cleanedModifier.$setOnInsert || {}));
+    if (!isEmpty(cleanedSetOnInsert)) {
+      cleanedModifier.$setOnInsert = cleanedSetOnInsert;
+    }
+  }
+  if (equals(cleanedModifier, {})) {
+    throw new Error("After cleaning your modifier is empty");
+  }
+  return cleanedModifier;
+}
+
 // src/createCollection/getMethods/validateModifier/validatePush.ts
+import { validate } from "@orion-js/schema";
 async function validatePush_default({ schema, operationDoc, operation }) {
   for (const key of Object.keys(operationDoc)) {
     const value = operationDoc[key];
@@ -570,12 +633,12 @@ async function validateSet_default({ schema, operationDoc }) {
 }
 
 // src/createCollection/getMethods/validateModifier/validateOperator.ts
-var shouldCheck = function(key) {
+var shouldCheck2 = function(key) {
   if (key === "$pushAll") throw new Error("$pushAll is not supported, use $push + $each");
   return ["$pull", "$pullAll", "$pop", "$slice"].indexOf(key) === -1;
 };
 async function validateOperator_default({ schema, operationDoc, operation }) {
-  if (!shouldCheck(operation)) return;
+  if (!shouldCheck2(operation)) return;
   if (operation === "$set") {
     await validateSet_default({ schema, operationDoc });
   } else if (operation === "$unset") {
@@ -632,69 +695,6 @@ async function validateUpsert_default(schema, selector, modifier) {
   await validateModifier(schema, omit(["$setOnInsert"], modifier));
 }
 
-// src/createCollection/getMethods/cleanModifier.ts
-import { cleanKey, clean } from "@orion-js/schema";
-var shouldCheck2 = (key) => {
-  if (key === "$pushAll") throw new Error("$pushAll is not supported; use $push + $each");
-  return ["$pull", "$pullAll", "$pop", "$slice"].indexOf(key) === -1;
-};
-async function cleanModifier(schema, modifier, { isUpsert } = { isUpsert: false }) {
-  const cleanedModifier = {};
-  for (const operation of Object.keys(modifier)) {
-    const operationDoc = modifier[operation];
-    cleanedModifier[operation] = {};
-    if (operation.slice(0, 1) !== "$") {
-      throw new Error(`Expected '${operation}' to be a modifier operator like '$set'`);
-    }
-    if (!shouldCheck2(operation)) {
-      cleanedModifier[operation] = operationDoc;
-      continue;
-    }
-    for (const key of Object.keys(operationDoc)) {
-      const value = operationDoc[key];
-      const cleanOptions = { forceDoc: operationDoc };
-      let cleaned = null;
-      if (operation === "$push" || operation === "$addToSet") {
-        if (typeof value === "object" && "$each" in value) {
-          const $each = await cleanKey(schema, key, value.$each, cleanOptions);
-          cleaned = { ...value, $each };
-        } else {
-          cleaned = await cleanKey(schema, `${key}.0`, value, cleanOptions);
-        }
-      }
-      if (operation === "$set") {
-        cleaned = await cleanKey(schema, key, value, cleanOptions);
-      }
-      if (operation === "$setOnInsert") {
-        cleaned = await cleanKey(schema, key, value, cleanOptions);
-      }
-      if (operation === "$inc") {
-        cleaned = await cleanKey(schema, key, value, cleanOptions);
-      }
-      if (operation === "$unset") {
-        const isPresent = await cleanKey(schema, key, "anyvalue", cleanOptions);
-        cleaned = !isNil(isPresent) ? "" : null;
-      }
-      if (cleaned !== void 0) {
-        cleanedModifier[operation][key] = cleaned;
-      }
-    }
-    if (isEmpty(cleanedModifier[operation])) {
-      delete cleanedModifier[operation];
-    }
-  }
-  if (isUpsert) {
-    const cleanedSetOnInsert = await clean(schema, fromDot(cleanedModifier.$setOnInsert || {}));
-    if (!isEmpty(cleanedSetOnInsert)) {
-      cleanedModifier.$setOnInsert = cleanedSetOnInsert;
-    }
-  }
-  if (equals(cleanedModifier, {})) {
-    throw new Error("After cleaning your modifier is empty");
-  }
-  return cleanedModifier;
-}
-
 // src/createCollection/getMethods/wrapErrors.ts
 import { ValidationError as ValidationError3 } from "@orion-js/schema";
 var wrapErrors = async (operation) => {
@@ -723,10 +723,10 @@ var wrapErrors = async (operation) => {
 
 // src/createCollection/getMethods/upsert.ts
 var upsert_default = (collection) => {
-  const upsert = async function(selectorArg, modifierArg, options = {}) {
+  const upsert = async (selectorArg, modifierArg, options = {}) => {
     await collection.connectionPromise;
     let modifier = modifierArg;
-    let selector = getSelector(arguments);
+    let selector = getSelector([selectorArg]);
     modifier.$setOnInsert = { ...modifier.$setOnInsert, _id: collection.generateId() };
     if (collection.schema) {
       const schema = collection.getSchema();
@@ -817,16 +817,17 @@ var updateMany_default = (collection) => {
 
 // src/createCollection/getMethods/updateAndFind.ts
 var updateAndFind_default = (collection) => {
-  const updateAndFind = async function(selector, modifier, options = {}) {
+  const updateAndFind = async (selector, modifier, options = {}) => {
     await collection.connectionPromise;
     return await wrapErrors(async () => {
-      return await collection.findOneAndUpdate(selector, modifier, {
+      const result = await collection.findOneAndUpdate(selector, modifier, {
         ...options,
         mongoOptions: {
           ...options.mongoOptions,
           returnDocument: "after"
         }
       });
+      return result;
     });
   };
   return updateAndFind;
@@ -911,10 +912,14 @@ var insertMany_default = (collection) => {
 
 // src/createCollection/getMethods/updateItem.ts
 function updateItem_default(collection) {
-  const updateItem = async function(item, modifier, options = {}) {
+  const updateItem = async (item, modifier, options = {}) => {
     await collection.connectionPromise;
     const updated = await wrapErrors(async () => {
-      return await collection.updateAndFind(item._id, modifier, options);
+      return await collection.updateAndFind(
+        item._id,
+        modifier,
+        options
+      );
     });
     for (const key in item) {
       delete item[key];
@@ -1110,10 +1115,11 @@ function loadData_default(collection) {
 import { generateId, generateUUID } from "@orion-js/helpers";
 import { ObjectId } from "bson";
 var getIdGenerator = (options) => {
-  var _a, _b;
-  if (!options.idPrefix && ((_a = options == null ? void 0 : options.schema) == null ? void 0 : _a._id)) {
-    const idField = options.schema._id.type;
-    if ((_b = idField.name) == null ? void 0 : _b.startsWith("typedId:")) {
+  var _a;
+  const schema = options.schema;
+  if (!options.idPrefix && (schema == null ? void 0 : schema._id)) {
+    const idField = schema._id.type;
+    if ((_a = idField.name) == null ? void 0 : _a.startsWith("typedId:")) {
       return () => {
         return idField.generateId();
       };
@@ -1384,20 +1390,21 @@ function prepareShema(schema) {
 function getSchema(options) {
   var _a;
   if (!options.schema) return;
-  if ((_a = options.schema[Symbol.metadata]) == null ? void 0 : _a._getModel) {
-    return options.schema[Symbol.metadata]._getModel().getSchema();
+  const schemaOption = options.schema;
+  if ((_a = schemaOption[Symbol.metadata]) == null ? void 0 : _a._getModel) {
+    return schemaOption[Symbol.metadata]._getModel().getSchema();
   }
-  if (options.schema.getSchema) {
-    const schema = options.schema.getSchema();
+  if (schemaOption.getSchema) {
+    const schema = schemaOption.getSchema();
     return prepareShema(schema);
   }
-  if (options.schema.getModel) {
-    const model = options.schema.getModel();
+  if (schemaOption.getModel) {
+    const model = schemaOption.getModel();
     const schema = model ? clone2(model.getSchema()) : {};
     return prepareShema(schema);
   }
-  if (type(options.schema) === "Object") {
-    return prepareShema(options.schema);
+  if (type(schemaOption) === "Object") {
+    return prepareShema(schemaOption);
   }
 }